db-mcp 3.0.2 → 5.0.0

package/dist/{chunk-L552U3QS.js → chunk-XLIYO3YA.js}

@@ -36,7 +36,11 @@ var TOOL_GROUPS = {
     "list_constraints",
     "date_add",
     "date_diff",
-    "alter_table"
+    "alter_table",
+    "enable_versioning",
+    "disable_versioning",
+    "check_version",
+    "conditional_update"
   ],
   json: [
     // CRUD + Query + Collection (8: crud.ts, query.ts, write.ts)
@@ -71,7 +75,7 @@ var TOOL_GROUPS = {
     "json_diff"
   ],
   text: [
-    // Text Tools (14 WASM)
+    // Text Tools (15 WASM)
     "regex_extract",
     "regex_match",
     "text_split",
@@ -85,6 +89,7 @@ var TOOL_GROUPS = {
     "text_normalize",
     "text_validate",
     "advanced_search",
+    "hybrid_search",
     "text_sentiment",
     // FTS5 Tools (5 Native-only)
     "fts_create",
@@ -94,7 +99,7 @@ var TOOL_GROUPS = {
     "fts_headline"
   ],
   stats: [
-    // Stats Tools (16 WASM)
+    // Stats Tools (13 WASM)
     "stats_basic",
     "stats_count",
     "stats_group_by",
@@ -136,7 +141,7 @@ var TOOL_GROUPS = {
     "vector_distance"
   ],
   admin: [
-    // Admin Tools (15: backup.ts, verify.ts, pragma.ts, reindex.ts, wal.ts)
+    // Admin Tools (12: backup.ts, verify.ts, pragma.ts)
     "backup",
     "analyze",
     "integrity_check",
@@ -149,7 +154,6 @@ var TOOL_GROUPS = {
     "pragma_optimize",
     "pragma_settings",
     "pragma_table_info",
-    "append_insight",
     // Virtual Table Tools (13: views.ts, vtable.ts, extensions.ts, analysis.ts)
     "generate_series",
     "create_view",
@@ -164,7 +168,7 @@ var TOOL_GROUPS = {
     "analyze_csv_schema",
     "create_rtree_table",
     "create_series_table",
-    // Database management (5: pragma.ts, backup/create.ts, reindex.ts, wal.ts)
+    // Database management (6: pragma.ts, backup/create.ts, dump.ts, reindex.ts, wal.ts)
     "attach_database",
     "detach_database",
     "vacuum_into",
@@ -223,19 +227,19 @@ var TOOL_GROUPS = {
   codemode: ["execute_code"]
 };
 var META_GROUPS = {
-  // General development - Core + JSON + Text (60 WASM / 65 Native)
+  // General development - Core + JSON + Text (65 WASM / 70 Native)
   starter: ["core", "json", "text", "codemode"],
-  // Data analysis - Core + JSON + Stats (63 WASM / 69 Native)
+  // Data analysis - Core + JSON + Stats (67 WASM / 73 Native)
   analytics: ["core", "json", "stats", "codemode"],
-  // Search workloads - Core + Text + Vector (46 WASM / 51 Native)
+  // Search workloads - Core + Text + Vector (51 WASM / 56 Native)
   search: ["core", "text", "vector", "codemode"],
-  // Geospatial workloads - Core + Geo + Vector (36 WASM / 43 Native)
+  // Geospatial workloads - Core + Geo + Vector (40 WASM / 47 Native)
   spatial: ["core", "geo", "vector", "codemode"],
-  // Schema development - Core + Introspection + Migration (37 tools)
+  // Schema development - Core + Introspection + Migration (41 tools)
   "dev-schema": ["core", "introspection", "migration", "codemode"],
-  // Bare minimum - Core (21 tools)
+  // Bare minimum - Core (25 tools)
   minimal: ["core", "codemode"],
-  // All group tools enabled (166 Native / 139 WASM — see TOOL COUNT TAXONOMY above)
+  // All group tools enabled (171 Native / 144 WASM — see TOOL COUNT TAXONOMY above)
   full: [
     "core",
     "json",
@@ -742,227 +746,270 @@ if (envLevel && envLevel in LEVEL_PRIORITY_CHECK) {
   logger.setLevel(envLevel);
 }
 
+// src/utils/errors/categories.ts
+var ErrorCategory = {
+  /** Input validation failures (invalid names, paths, types) */
+  VALIDATION: "validation",
+  /** Database connection issues */
+  CONNECTION: "connection",
+  /** SQL execution errors */
+  QUERY: "query",
+  /** Authorization/permission failures */
+  PERMISSION: "permission",
+  /** Configuration/setup issues */
+  CONFIGURATION: "config",
+  /** Missing resources (tables, columns, views) */
+  RESOURCE: "resource",
+  /** Authentication failures (invalid credentials, expired tokens) */
+  AUTHENTICATION: "authentication",
+  /** Authorization failures (insufficient scope/permissions) */
+  AUTHORIZATION: "authorization",
+  /** Unexpected internal errors */
+  INTERNAL: "internal",
+  /** Execution timeout errors */
+  TIMEOUT: "timeout",
+  /** Rate limit enforcement errors */
+  RATE_LIMIT: "rate_limit"
+};
+
 // src/utils/errors/suggestions.ts
 var ERROR_SUGGESTIONS = [
   // Validation errors
   {
     pattern: /invalid table name/i,
     suggestion: "Table names must start with a letter or underscore, followed by letters, numbers, or underscores only.",
-    category: "validation" /* VALIDATION */
+    category: ErrorCategory.VALIDATION
   },
   {
     pattern: /invalid column name/i,
     suggestion: "Column names must start with a letter or underscore, followed by letters, numbers, or underscores only.",
-    category: "validation" /* VALIDATION */
+    category: ErrorCategory.VALIDATION
   },
   {
     pattern: /invalid (view|index) name/i,
     suggestion: "Names must start with a letter or underscore, followed by alphanumeric characters only.",
-    category: "validation" /* VALIDATION */
+    category: ErrorCategory.VALIDATION
   },
   {
     pattern: /json path must start with \$/i,
     suggestion: "JSON paths use $ as the root. Example: $.name, $.items[0], $.nested.property",
-    category: "validation" /* VALIDATION */
+    category: ErrorCategory.VALIDATION
   },
   {
     pattern: /vector dimensions must match/i,
     suggestion: "All vectors in comparison must have the same number of dimensions.",
-    category: "validation" /* VALIDATION */
+    category: ErrorCategory.VALIDATION
   },
   {
     pattern: /insufficient data/i,
     suggestion: "Not enough data points for the requested analysis. Add more data or reduce the degree.",
-    category: "validation" /* VALIDATION */
+    category: ErrorCategory.VALIDATION
   },
   // Resource errors — specific codes for table/column not found
   {
     pattern: /no such table[:\s]*(['"]?)([\w.]+)\1/i,
     suggestion: "Table not found. Run sqlite_list_tables to see available tables.",
-    category: "resource" /* RESOURCE */,
+    category: ErrorCategory.RESOURCE,
     code: "TABLE_NOT_FOUND"
   },
   {
     pattern: /no such column[:\s]*(['"]?)([\w.]+)\1/i,
     suggestion: "Column not found. Use sqlite_describe_table to see available columns.",
-    category: "resource" /* RESOURCE */,
+    category: ErrorCategory.RESOURCE,
     code: "COLUMN_NOT_FOUND"
   },
   {
-    pattern: /has no column named/i,
+    pattern: /has no column named\s+(['"]?)([\w.]+)\1/i,
     suggestion: "Column not found in target table. Use sqlite_describe_table to verify column names before INSERT or UPDATE.",
-    category: "resource" /* RESOURCE */,
+    category: ErrorCategory.RESOURCE,
     code: "COLUMN_NOT_FOUND"
   },
   {
     pattern: /no such view[:\s]*(['"]?)([\w.]+)\1/i,
     suggestion: "View not found. Run sqlite_list_views to see available views.",
-    category: "resource" /* RESOURCE */,
+    category: ErrorCategory.RESOURCE,
     code: "VIEW_NOT_FOUND"
   },
   {
     pattern: /filename.*does not exist/i,
     suggestion: "File not found. Verify the absolute path exists and is readable.",
-    category: "resource" /* RESOURCE */,
+    category: ErrorCategory.RESOURCE,
     code: "FILE_NOT_FOUND"
   },
   {
     pattern: /table .* already exists/i,
     suggestion: "Table already exists. Use CREATE TABLE IF NOT EXISTS or drop the existing table first.",
-    category: "resource" /* RESOURCE */,
+    category: ErrorCategory.RESOURCE,
     code: "TABLE_ALREADY_EXISTS"
   },
   {
     pattern: /index .* already exists/i,
     suggestion: "Index already exists. Use CREATE INDEX IF NOT EXISTS or drop the existing index first.",
-    category: "resource" /* RESOURCE */,
+    category: ErrorCategory.RESOURCE,
     code: "INDEX_ALREADY_EXISTS"
   },
   // JSON-specific errors — often caused by wrong column name
   {
     pattern: /malformed JSON/i,
     suggestion: "The JSON data is malformed. This commonly occurs when the column name is incorrect \u2014 SQLite treats the unresolved identifier as a literal string. Verify the column exists with sqlite_describe_table.",
-    category: "query" /* QUERY */,
+    category: ErrorCategory.QUERY,
     code: "MALFORMED_JSON"
   },
   // Query errors
   {
     pattern: /syntax error/i,
     suggestion: "Check SQL syntax. Common issues: missing quotes, commas, parentheses, or reserved word conflicts.",
-    category: "query" /* QUERY */
+    category: ErrorCategory.QUERY
   },
   {
     pattern: /UNIQUE constraint failed/i,
     suggestion: "A row with this value already exists. Use UPDATE to modify existing data or check for duplicates.",
-    category: "query" /* QUERY */,
+    category: ErrorCategory.QUERY,
     code: "CONSTRAINT_VIOLATION"
   },
   {
     pattern: /FOREIGN KEY constraint failed/i,
     suggestion: "The referenced row does not exist. Ensure the parent record exists before inserting.",
-    category: "query" /* QUERY */,
+    category: ErrorCategory.QUERY,
     code: "CONSTRAINT_VIOLATION"
   },
   {
     pattern: /NOT NULL constraint failed/i,
     suggestion: "A required column is missing a value. Provide a value or set a default.",
-    category: "query" /* QUERY */,
+    category: ErrorCategory.QUERY,
     code: "CONSTRAINT_VIOLATION"
   },
   {
     pattern: /CHECK constraint failed/i,
     suggestion: "The value does not meet the column's check constraint requirements.",
-    category: "query" /* QUERY */,
+    category: ErrorCategory.QUERY,
     code: "CONSTRAINT_VIOLATION"
   },
   {
     pattern: /incomplete input/i,
     suggestion: "SQL statement is incomplete. Check for missing clauses, closing parentheses, or semicolons.",
-    category: "query" /* QUERY */
+    category: ErrorCategory.QUERY
   },
   {
     pattern: /more than one statement/i,
     suggestion: "Only one SQL statement per call is allowed. Split multiple statements into separate calls or use sqlite_execute_code for multi-step operations.",
-    category: "query" /* QUERY */
+    category: ErrorCategory.QUERY
   },
   {
     pattern: /too few parameter/i,
     suggestion: "Not enough parameter values provided for the prepared statement placeholders (?). Ensure params array matches the number of ? placeholders in the query.",
-    category: "query" /* QUERY */
+    category: ErrorCategory.QUERY
   },
   // Connection errors
   {
     pattern: /not connected/i,
     suggestion: "Database connection not established. Ensure the database is configured and connected.",
-    category: "connection" /* CONNECTION */
+    category: ErrorCategory.CONNECTION
   },
   {
     pattern: /cannot start a transaction within a transaction/i,
     suggestion: "A transaction is already active. Commit or rollback the current transaction first, or use sqlite_transaction_execute for atomic multi-statement operations.",
-    category: "query" /* QUERY */,
+    category: ErrorCategory.QUERY,
     code: "TRANSACTION_CONFLICT"
   },
   {
     pattern: /no transaction is active/i,
     suggestion: "No transaction is active. Start a transaction using sqlite_transaction_begin first.",
-    category: "query" /* QUERY */,
+    category: ErrorCategory.QUERY,
     code: "TRANSACTION_NOT_ACTIVE"
   },
   {
     pattern: /no such savepoint/i,
     suggestion: "The specified savepoint does not exist. Verify the savepoint name and ensure it hasn't already been released or rolled back.",
-    category: "query" /* QUERY */,
+    category: ErrorCategory.QUERY,
     code: "SAVEPOINT_NOT_FOUND"
   },
   {
     pattern: /database is locked/i,
     suggestion: "Database is being used by another process. Wait and retry, or check for long-running transactions.",
-    category: "connection" /* CONNECTION */
+    category: ErrorCategory.CONNECTION
   },
   // Permission errors
   {
     pattern: /readonly database/i,
     suggestion: "Database is in read-only mode. Check file permissions or connection settings.",
-    category: "permission" /* PERMISSION */
+    category: ErrorCategory.PERMISSION
   },
   {
     pattern: /attempt to write a readonly/i,
     suggestion: "Write operations are not allowed. Check database configuration.",
-    category: "permission" /* PERMISSION */
+    category: ErrorCategory.PERMISSION
   },
   // Codemode errors
   {
     pattern: /code validation failed/i,
     suggestion: "Check for blocked patterns: require(), process., eval(), Function(), import(). Use sqlite.* API instead.",
-    category: "validation" /* VALIDATION */
+    category: ErrorCategory.VALIDATION
   },
   {
     pattern: /rate limit exceeded/i,
     suggestion: "Wait before retrying. Combine multiple operations into fewer execute_code calls.",
-    category: "permission" /* PERMISSION */
+    category: ErrorCategory.RATE_LIMIT
   },
   {
     pattern: /execution timed out/i,
     suggestion: "Reduce code complexity or increase timeout (max 30s). Break into smaller operations.",
-    category: "query" /* QUERY */
+    category: ErrorCategory.TIMEOUT
   },
   {
     pattern: /sandbox.*not initialized/i,
     suggestion: "Internal sandbox error. Retry the operation.",
-    category: "internal" /* INTERNAL */
+    category: ErrorCategory.INTERNAL
   },
   // Extension errors
   {
     pattern: /extension.*not (available|installed|loaded|found)/i,
     suggestion: "Extension is not available. Check CLI flags, environment variables, or platform compatibility.",
-    category: "config" /* CONFIGURATION */,
+    category: ErrorCategory.CONFIGURATION,
     code: "EXTENSION_MISSING"
   },
   // Custom JS errors mapped from tools
   {
     pattern: /invalid identifier/i,
     suggestion: "Identifiers must start with a letter or underscore and contain only alphanumeric characters or underscores. Ensure the name follows SQLite identifier rules.",
-    category: "validation" /* VALIDATION */,
+    category: ErrorCategory.VALIDATION,
     code: "INVALID_IDENTIFIER"
   },
   {
     pattern: /(expected property name|unexpected token|in JSON at position|Expected double-quoted property name)/i,
     suggestion: "The JSON data provided is malformed. Ensure the input string is valid JSON.",
-    category: "validation" /* VALIDATION */,
+    category: ErrorCategory.VALIDATION,
     code: "MALFORMED_JSON"
   }
 ];
+var suggestionCache = /* @__PURE__ */ new Map();
+var MAX_CACHE_SIZE = 1e3;
 function findSuggestion(message) {
+  const cached = suggestionCache.get(message);
+  if (cached) {
+    suggestionCache.delete(message);
+    suggestionCache.set(message, cached);
+    return cached;
+  }
+  let result = null;
   for (const entry of ERROR_SUGGESTIONS) {
-    if (entry.pattern.test(message)) {
-      return {
+    const match = entry.pattern.exec(message);
+    if (match) {
+      result = {
         suggestion: entry.suggestion,
         category: entry.category,
-        code: entry.code
+        code: entry.code,
+        match
       };
+      break;
     }
   }
-  return null;
+  if (suggestionCache.size >= MAX_CACHE_SIZE) {
+    const firstKey = suggestionCache.keys().next().value;
+    if (firstKey) suggestionCache.delete(firstKey);
+  }
+  suggestionCache.set(message, result);
+  return result;
 }
 
 // src/utils/errors/base.ts
@@ -1014,7 +1061,7 @@ var DbMcpError = class extends Error {
 // src/utils/errors/classes.ts
 var ValidationError = class extends DbMcpError {
   constructor(message, code = "VALIDATION_ERROR", options) {
-    super(message, code, "validation" /* VALIDATION */, {
+    super(message, code, ErrorCategory.VALIDATION, {
       ...options,
       recoverable: false
     });
@@ -1022,7 +1069,7 @@ var ValidationError = class extends DbMcpError {
 };
 var ConnectionError = class extends DbMcpError {
   constructor(message, code = "CONNECTION_ERROR", options) {
-    super(message, code, "connection" /* CONNECTION */, {
+    super(message, code, ErrorCategory.CONNECTION, {
       ...options,
       recoverable: true
       // Connection errors are often transient
@@ -1031,7 +1078,7 @@ var ConnectionError = class extends DbMcpError {
 };
 var QueryError = class extends DbMcpError {
   constructor(message, code = "QUERY_ERROR", options) {
-    super(message, code, "query" /* QUERY */, {
+    super(message, code, ErrorCategory.QUERY, {
       ...options,
       details: {
         ...options?.details,
@@ -1043,7 +1090,7 @@ var QueryError = class extends DbMcpError {
 };
 var ResourceNotFoundError = class extends DbMcpError {
   constructor(message, code = "RESOURCE_NOT_FOUND", options) {
-    super(message, code, "resource" /* RESOURCE */, {
+    super(message, code, ErrorCategory.RESOURCE, {
       ...options,
       details: {
         ...options?.details,
@@ -1056,7 +1103,15 @@ var ResourceNotFoundError = class extends DbMcpError {
 };
 var ConfigurationError = class extends DbMcpError {
   constructor(message, code = "CONFIG_ERROR", options) {
-    super(message, code, "config" /* CONFIGURATION */, {
+    super(message, code, ErrorCategory.CONFIGURATION, {
+      ...options,
+      recoverable: false
+    });
+  }
+};
+var InternalError = class extends DbMcpError {
+  constructor(message, code = "INTERNAL_ERROR", options) {
+    super(message, code, ErrorCategory.INTERNAL, {
       ...options,
       recoverable: false
     });
@@ -1064,7 +1119,7 @@ var ConfigurationError = class extends DbMcpError {
 };
 var AuthenticationError = class extends DbMcpError {
   constructor(message, code = "AUTHENTICATION_ERROR", options) {
-    super(message, code, "authentication" /* AUTHENTICATION */, {
+    super(message, code, ErrorCategory.AUTHENTICATION, {
       ...options,
       recoverable: false
     });
@@ -1072,7 +1127,7 @@ var AuthenticationError = class extends DbMcpError {
 };
 var AuthorizationError = class extends DbMcpError {
   constructor(message, code = "AUTHORIZATION_ERROR", options) {
-    super(message, code, "authorization" /* AUTHORIZATION */, {
+    super(message, code, ErrorCategory.AUTHORIZATION, {
       ...options,
       recoverable: false
     });
@@ -1083,7 +1138,7 @@ var ExtensionNotAvailableError = class extends DbMcpError {
     const isWasm = options?.wasmLimitation ?? options?.details?.["wasmLimitation"] ?? false;
     const baseMessage = `Extension '${extensionName}' is not installed or available`;
     const message = isWasm === true ? `${baseMessage} in WASM mode` : baseMessage;
-    super(message, "EXTENSION_MISSING", "config" /* CONFIGURATION */, {
+    super(message, "EXTENSION_MISSING", ErrorCategory.CONFIGURATION, {
       suggestion: options?.suggestion ?? `Install or enable the '${extensionName}' extension. Check environment variable or CLI flag configuration.`,
       details: {
         extension: extensionName,
@@ -1095,10 +1150,53 @@ var ExtensionNotAvailableError = class extends DbMcpError {
     });
   }
 };
+var TimeoutError = class extends DbMcpError {
+  constructor(message, code = "TIMEOUT_ERROR", options) {
+    super(message, code, ErrorCategory.TIMEOUT, {
+      ...options,
+      details: {
+        ...options?.details,
+        timeoutMs: options?.timeoutMs
+      },
+      recoverable: true
+      // Timeouts are retriable with increased timeout or simplified logic
+    });
+  }
+};
+var RateLimitError = class extends DbMcpError {
+  constructor(message, code = "RATE_LIMIT_ERROR", options) {
+    super(message, code, ErrorCategory.RATE_LIMIT, {
+      ...options,
+      details: {
+        ...options?.details,
+        retryAfterMs: options?.retryAfterMs,
+        limit: options?.limit
+      },
+      recoverable: true
+      // Rate limits are transient — retry after backoff
+    });
+  }
+};
+var ConflictError = class extends DbMcpError {
+  constructor(message, code = "CONFLICT_ERROR", options) {
+    super(message, code, ErrorCategory.QUERY, {
+      ...options,
+      details: {
+        ...options?.details,
+        conflictType: options?.conflictType
+      },
+      recoverable: true
+      // Conflicts are retriable after re-reading current state
+    });
+  }
+};
 
 // src/utils/errors/format.ts
 function sanitizeErrorMessage(msg) {
   if (!msg || typeof msg !== "string") return msg;
+  if (!msg.includes(":") && !msg.includes("/") && !msg.includes("\\") && !msg.includes("=")) {
+    return msg;
+  }
   return msg.replace(/[a-zA-Z]:\\[^:\n]*\\/g, "<redacted_path>\\").replace(/(file:|sqlite:|\/)[^:\s]+(\/[^:\s]*)/g, "<redacted_path>").replace(
     /([a-zA-Z0-9+.-]+:\/\/[^:]+:)[^@\s]+(@)/g,
     "$1<redacted_credential>$2"
@@ -1111,15 +1209,17 @@ function sanitizeErrorMessage(msg) {
   );
 }
 var CATEGORY_DEFAULT_CODES = {
-  ["validation" /* VALIDATION */]: "VALIDATION_ERROR",
-  ["connection" /* CONNECTION */]: "CONNECTION_ERROR",
-  ["query" /* QUERY */]: "QUERY_ERROR",
-  ["permission" /* PERMISSION */]: "PERMISSION_ERROR",
-  ["config" /* CONFIGURATION */]: "CONFIG_ERROR",
-  ["resource" /* RESOURCE */]: "RESOURCE_ERROR",
-  ["authentication" /* AUTHENTICATION */]: "AUTHENTICATION_ERROR",
-  ["authorization" /* AUTHORIZATION */]: "AUTHORIZATION_ERROR",
-  ["internal" /* INTERNAL */]: "UNKNOWN_ERROR"
+  [ErrorCategory.VALIDATION]: "VALIDATION_ERROR",
+  [ErrorCategory.CONNECTION]: "CONNECTION_ERROR",
+  [ErrorCategory.QUERY]: "QUERY_ERROR",
+  [ErrorCategory.PERMISSION]: "PERMISSION_ERROR",
+  [ErrorCategory.CONFIGURATION]: "CONFIG_ERROR",
+  [ErrorCategory.RESOURCE]: "RESOURCE_ERROR",
+  [ErrorCategory.AUTHENTICATION]: "AUTHENTICATION_ERROR",
+  [ErrorCategory.AUTHORIZATION]: "AUTHORIZATION_ERROR",
+  [ErrorCategory.INTERNAL]: "UNKNOWN_ERROR",
+  [ErrorCategory.TIMEOUT]: "TIMEOUT_ERROR",
+  [ErrorCategory.RATE_LIMIT]: "RATE_LIMIT_ERROR"
 };
 function formatZodError(error) {
   if (!("issues" in error) || !Array.isArray(error["issues"])) {
@@ -1144,7 +1244,7 @@ function formatHandlerError(error, _context) {
         success: false,
         error: sanitizeErrorMessage(zodMessage),
         code: "VALIDATION_ERROR",
-        category: "validation" /* VALIDATION */,
+        category: ErrorCategory.VALIDATION,
         suggestion: void 0,
         recoverable: false,
         details: void 0
@@ -1153,7 +1253,7 @@ function formatHandlerError(error, _context) {
   }
   if (error instanceof Error) {
     const match = findSuggestion(error.message);
-    const category = match?.category ?? "internal" /* INTERNAL */;
+    const category = match?.category ?? ErrorCategory.INTERNAL;
     return {
       success: false,
       error: sanitizeErrorMessage(error.message),
@@ -1168,12 +1268,230 @@ function formatHandlerError(error, _context) {
     success: false,
     error: sanitizeErrorMessage(String(error)),
     code: "UNKNOWN_ERROR",
-    category: "internal" /* INTERNAL */,
+    category: ErrorCategory.INTERNAL,
     suggestion: void 0,
     recoverable: false,
     details: void 0
   };
 }
+
+// src/observability/metrics.ts
+var MAX_SAMPLES = 1e3;
+var ToolMetric = class {
+  calls = 0;
+  errors = 0;
+  tokens = 0;
+  // Circular buffer for latency samples
+  samples = new Array(MAX_SAMPLES).fill(0);
+  sampleIndex = 0;
+  sampleCount = 0;
+  record(durationMs, success, tokens = 0) {
+    this.calls++;
+    if (!success) this.errors++;
+    this.tokens += tokens;
+    this.samples[this.sampleIndex] = durationMs;
+    this.sampleIndex = (this.sampleIndex + 1) % MAX_SAMPLES;
+    if (this.sampleCount < MAX_SAMPLES) {
+      this.sampleCount++;
+    }
+  }
+  getSummary() {
+    if (this.sampleCount === 0) {
+      return {
+        calls: this.calls,
+        errors: this.errors,
+        tokens: this.tokens,
+        p50: 0,
+        p95: 0,
+        p99: 0
+      };
+    }
+    const activeSamples = this.samples.slice(0, this.sampleCount).sort((a, b) => a - b);
+    return {
+      calls: this.calls,
+      errors: this.errors,
+      tokens: this.tokens,
+      p50: this.getPercentile(activeSamples, 0.5),
+      p95: this.getPercentile(activeSamples, 0.95),
+      p99: this.getPercentile(activeSamples, 0.99)
+    };
+  }
+  getPercentile(sorted, p) {
+    if (sorted.length === 0) return 0;
+    const idx = (sorted.length - 1) * p;
+    const base = Math.floor(idx);
+    const rest = idx - base;
+    const v0 = sorted[base] ?? 0;
+    const v1 = sorted[base + 1];
+    if (v1 !== void 0) {
+      return Math.round(v0 + rest * (v1 - v0));
+    } else {
+      return v0;
+    }
+  }
+};
+var ResourceMetric = class {
+  reads = 0;
+  record() {
+    this.reads++;
+  }
+  getSummary() {
+    return { reads: this.reads };
+  }
+};
+var MetricsRegistry = class {
+  tools = /* @__PURE__ */ new Map();
+  resources = /* @__PURE__ */ new Map();
+  systemDb = null;
+  flushTimer = null;
+  setSystemDb(systemDb) {
+    this.systemDb = systemDb;
+    this.loadHistorical();
+    this.startFlushTimer();
+  }
+  loadHistorical() {
+    if (!this.systemDb) return;
+    try {
+      const db = this.systemDb.getDb();
+      const rows = db.prepare(
+        `
+        SELECT tool, MAX(calls) as max_calls, MAX(errors) as max_errors, MAX(tokens) as max_tokens
+        FROM metrics_snapshots
+        GROUP BY tool
+      `
+      ).all();
+      for (const row of rows) {
+        const metric = new ToolMetric();
+        metric.calls = row.max_calls;
+        metric.errors = row.max_errors;
+        metric.tokens = row.max_tokens;
+        this.tools.set(row.tool, metric);
+      }
+      logger.info(`Loaded historical metrics for ${rows.length} tools`, {
+        module: "METRICS"
+      });
+    } catch (err) {
+      logger.warning("Failed to load historical metrics", {
+        module: "METRICS",
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+  }
+  startFlushTimer() {
+    if (this.flushTimer) clearInterval(this.flushTimer);
+    this.flushTimer = setInterval(
+      () => {
+        this.flushToDb();
+      },
+      5 * 60 * 1e3
+    );
+    this.flushTimer.unref();
+  }
+  flushToDb() {
+    if (!this.systemDb) return;
+    try {
+      const db = this.systemDb.getDb();
+      const stmt = db.prepare(`
+        INSERT INTO metrics_snapshots (timestamp, tool, calls, errors, p50, p95, p99, tokens)
+        VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+      `);
+      const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+      const transaction = db.transaction(() => {
+        for (const [name, metric] of this.tools.entries()) {
+          const summary = metric.getSummary();
+          stmt.run(
+            timestamp,
+            name,
+            summary.calls,
+            summary.errors,
+            summary.p50,
+            summary.p95,
+            summary.p99,
+            summary.tokens
+          );
+        }
+      });
+      transaction();
+    } catch (err) {
+      logger.warning("Failed to flush metrics to db", {
+        module: "METRICS",
+        error: err instanceof Error ? err : new Error(String(err))
+      });
+    }
+  }
+  close() {
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    this.flushToDb();
+  }
+  recordToolCall(toolName, durationMs, success, tokens = 0) {
+    let metric = this.tools.get(toolName);
+    if (!metric) {
+      metric = new ToolMetric();
+      this.tools.set(toolName, metric);
+    }
+    metric.record(durationMs, success, tokens);
+  }
+  recordResourceRead(uri) {
+    let metric = this.resources.get(uri);
+    if (!metric) {
+      metric = new ResourceMetric();
+      this.resources.set(uri, metric);
+    }
+    metric.record();
+  }
+  getSummary() {
+    const toolsSummary = {};
+    for (const [name, metric] of this.tools.entries()) {
+      toolsSummary[name] = metric.getSummary();
+    }
+    const resourcesSummary = {};
+    for (const [uri, metric] of this.resources.entries()) {
+      resourcesSummary[uri] = metric.getSummary();
+    }
+    return {
+      tools: toolsSummary,
+      resources: resourcesSummary,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  toPrometheus() {
+    const lines = [];
+    lines.push("# HELP db_mcp_tool_calls_total Total tool calls");
+    lines.push("# TYPE db_mcp_tool_calls_total counter");
+    lines.push("# HELP db_mcp_tool_errors_total Total tool errors");
+    lines.push("# TYPE db_mcp_tool_errors_total counter");
+    lines.push("# HELP db_mcp_tool_tokens_total Total tokens estimated");
+    lines.push("# TYPE db_mcp_tool_tokens_total counter");
+    lines.push("# HELP db_mcp_tool_latency_ms_p50 P50 Latency (ms)");
+    lines.push("# TYPE db_mcp_tool_latency_ms_p50 gauge");
+    lines.push("# HELP db_mcp_tool_latency_ms_p95 P95 Latency (ms)");
+    lines.push("# TYPE db_mcp_tool_latency_ms_p95 gauge");
+    lines.push("# HELP db_mcp_tool_latency_ms_p99 P99 Latency (ms)");
+    lines.push("# TYPE db_mcp_tool_latency_ms_p99 gauge");
+    for (const [name, metric] of this.tools.entries()) {
+      const summary = metric.getSummary();
+      const labels = `{tool="${name}"}`;
+      lines.push(`db_mcp_tool_calls_total${labels} ${summary.calls}`);
+      lines.push(`db_mcp_tool_errors_total${labels} ${summary.errors}`);
+      lines.push(`db_mcp_tool_tokens_total${labels} ${summary.tokens}`);
+      lines.push(`db_mcp_tool_latency_ms_p50${labels} ${summary.p50}`);
+      lines.push(`db_mcp_tool_latency_ms_p95${labels} ${summary.p95}`);
+      lines.push(`db_mcp_tool_latency_ms_p99${labels} ${summary.p99}`);
+    }
+    lines.push("# HELP db_mcp_resource_reads_total Total resource reads");
+    lines.push("# TYPE db_mcp_resource_reads_total counter");
+    for (const [uri, metric] of this.resources.entries()) {
+      const summary = metric.getSummary();
+      const labels = `{resource="${uri}"}`;
+      lines.push(`db_mcp_resource_reads_total${labels} ${summary.reads}`);
+    }
+    return lines.join("\n") + "\n";
+  }
+};
+var metrics = new MetricsRegistry();
 var authContextStorage = new AsyncLocalStorage();
 function runWithAuthContext(context, fn) {
   return authContextStorage.run(context, fn);
@@ -1247,8 +1565,12 @@ adminToolNames.push(
   "sqlite_audit_cleanup",
   "sqlite_audit_diff_backup",
   "sqlite_audit_restore_backup",
-  "drop_table"
+  "drop_table",
   // explicitly admin since it is destructive, despite being in core
+  "enable_versioning",
+  // admin scope needed for DDL
+  "disable_versioning"
+  // admin scope needed for DDL
 );
 withSqlitePrefix(adminToolNames);
 var READ_ONLY_TOOLS = withSqlitePrefix([
@@ -1263,6 +1585,7 @@ var READ_ONLY_TOOLS = withSqlitePrefix([
   "list_constraints",
   "date_add",
   "date_diff",
+  "check_version",
   // JSON read operations
   "json_valid",
   "json_extract",
@@ -1359,6 +1682,7 @@ var WRITE_TOOLS = withSqlitePrefix([
   "create_trigger",
   "drop_trigger",
   "alter_table",
+  "conditional_update",
   // JSON write operations
   "json_insert",
   "json_update",
@@ -1457,7 +1781,7 @@ var OAuthError = class extends DbMcpError {
   /** WWW-Authenticate header value */
   wwwAuthenticate;
   constructor(message, code, httpStatus, details, wwwAuthenticate) {
-    super(message, code, "authentication" /* AUTHENTICATION */, { details });
+    super(message, code, ErrorCategory.AUTHENTICATION, { details });
     this.name = "OAuthError";
     this.httpStatus = httpStatus;
     this.wwwAuthenticate = wwwAuthenticate;
@@ -1555,4 +1879,4 @@ function isOAuthError(error) {
   return error instanceof OAuthError;
 }
 
-export { ALL_TOOL_GROUPS, AuthServerDiscoveryError, AuthenticationError, AuthorizationError, BASE_SCOPES, ConfigurationError, ConnectionError, DbMcpError, ERROR_CODES, ExtensionNotAvailableError, InsufficientScopeError, InvalidSignatureError, InvalidTokenError, JwksFetchError, META_GROUPS, QueryError, ResourceNotFoundError, SCOPES, SUPPORTED_SCOPES, TOOL_GROUPS, TokenExpiredError, TokenMissingError, ValidationError, createModuleLogger, filterTools, findSuggestion, formatHandlerError, getAuthContext, getFilterSummary, getToolFilterFromEnv, hasAdminScope, hasReadScope, isOAuthError, isToolEnabled, logger, parseScopes, parseToolFilter, registerToolScopes, runWithAuthContext, sanitizeErrorMessage, scopesGrantToolAccess };
+export { ALL_TOOL_GROUPS, AuthServerDiscoveryError, AuthenticationError, AuthorizationError, BASE_SCOPES, ConfigurationError, ConflictError, ConnectionError, DbMcpError, ERROR_CODES, ErrorCategory, ExtensionNotAvailableError, InsufficientScopeError, InternalError, InvalidSignatureError, InvalidTokenError, JwksFetchError, META_GROUPS, QueryError, RateLimitError, ResourceNotFoundError, SCOPES, SUPPORTED_SCOPES, TOOL_GROUPS, TimeoutError, TokenExpiredError, TokenMissingError, ValidationError, createModuleLogger, filterTools, findSuggestion, formatHandlerError, getAuthContext, getFilterSummary, getToolFilterFromEnv, hasAdminScope, hasReadScope, isOAuthError, isToolEnabled, logger, metrics, parseScopes, parseToolFilter, registerToolScopes, runWithAuthContext, sanitizeErrorMessage, scopesGrantToolAccess };