db-mcp 1.0.2 → 1.1.0

package/dist/sqlite-native-D2LH5ZT7.js

@@ -0,0 +1,2498 @@
+import { TransactionBeginOutputSchema, TransactionCommitOutputSchema, TransactionRollbackOutputSchema, TransactionSavepointOutputSchema, TransactionReleaseOutputSchema, TransactionRollbackToOutputSchema, TransactionExecuteOutputSchema, WindowRowNumberOutputSchema, validateWhereClause, WindowRankOutputSchema, WindowLagLeadOutputSchema, WindowRunningTotalOutputSchema, resolveAliases, WindowMovingAvgOutputSchema, WindowNtileOutputSchema, autoEnableWal, detectAndSetJsonbSupport, SchemaManager, applyCommonPragmas, isDDL, getResourceDefinitions, getPromptDefinitions, SpatialiteLoadOutputSchema, SpatialiteCreateTableOutputSchema, SpatialiteQueryOutputSchema, SpatialiteAnalyzeOutputSchema, SpatialiteIndexOutputSchema, SpatialiteTransformOutputSchema, SpatialiteImportOutputSchema, normalizeSqliteParams, getCoreTools, getJsonOperationTools, getJsonHelperTools, getTextTools, getStatsTools, getVirtualTools, getVectorTools, getGeoTools, getAdminTools, getIntrospectionTools, getMigrationTools, getCodeModeTools, FtsCreateOutputSchema, sanitizeIdentifier, FtsSearchOutputSchema, validateTableExists, FtsRebuildOutputSchema } from './chunk-DWJXQEFA.js';
+import { DatabaseAdapter } from './chunk-Z2GFQU3G.js';
+import { write, readOnly, admin, getToolGroupIcon, idempotent } from './chunk-S5IDDSSB.js';
+import { formatHandlerError, ValidationError, ConfigurationError, ConnectionError, ResourceNotFoundError, QueryError } from './chunk-4IA3DB5C.js';
+import { logger, ERROR_CODES, DbMcpError } from './chunk-AOUL5SHS.js';
+import Database from 'better-sqlite3';
+import { z } from 'zod';
+import path from 'path';
+import fs from 'fs';
+import { fileURLToPath } from 'url';
+
+function buildFts5UnavailableError(tableName) {
+  return {
+    success: false,
+    message: "FTS5 module unavailable",
+    tableName: tableName ?? "",
+    error: "FTS5 module unavailable",
+    hint: "FTS5 requires native SQLite backend (--sqlite-native). WASM mode (sql.js) does not include this module."
+  };
+}
+function isFts5UnavailableError(error) {
+  return error instanceof Error && error.message.toLowerCase().includes("no such module: fts5");
+}
+function isFts5Available(adapter) {
+  return adapter.isNativeBackend();
+}
+function buildFts5SearchUnavailableError() {
+  return {
+    success: false,
+    rowCount: 0,
+    results: [],
+    error: "FTS5 module unavailable",
+    hint: "FTS5 requires native SQLite backend (--sqlite-native). WASM mode (sql.js) does not include this module."
+  };
+}
+var coerceEnumValues = (allowed) => (val) => typeof val === "string" && allowed.includes(val) ? val : void 0;
+var FtsCreateSchema = z.object({
+  tableName: z.string().describe("Name of the FTS table to create"),
+  sourceTable: z.string().describe("Source table to index"),
+  columns: z.array(z.string()).describe("Columns to include in the index"),
+  contentTable: z.string().optional().describe("Content table for external content FTS"),
+  tokenizer: z.preprocess(
+    coerceEnumValues(["unicode61", "ascii", "porter"]),
+    z.enum(["unicode61", "ascii", "porter"]).optional().default("unicode61")
+  ),
+  createTriggers: z.boolean().optional().default(true).describe(
+    "Create INSERT/UPDATE/DELETE triggers for auto-sync (only for external content tables)"
+  )
+});
+var FtsSearchSchema = z.object({
+  table: z.string().describe("FTS table name"),
+  query: z.string().describe("Full-text search query"),
+  columns: z.array(z.string()).optional().describe("Specific columns to search"),
+  limit: z.preprocess(
+    (val) => typeof val === "string" ? isNaN(Number(val)) ? void 0 : Number(val) : val,
+    z.number().optional().default(100)
+  ),
+  highlight: z.boolean().optional().default(false).describe("Include highlighted snippets")
+});
+var FtsRebuildSchema = z.object({
+  table: z.string().describe("FTS table name to rebuild")
+});
+var FtsMatchInfoSchema = z.object({
+  table: z.string().describe("FTS table name"),
+  query: z.string().describe("Full-text search query"),
+  format: z.preprocess(
+    coerceEnumValues(["bm25", "rank"]),
+    z.enum(["bm25", "rank"]).optional().default("bm25")
+  )
+});
+function getFtsTools(adapter) {
+  return [
+    createFtsCreateTool(adapter),
+    createFtsSearchTool(adapter),
+    createFtsRebuildTool(adapter),
+    createFtsMatchInfoTool(adapter)
+  ];
+}
+function createFtsCreateTool(adapter) {
+  return {
+    name: "sqlite_fts_create",
+    description: "Create an FTS5 full-text search virtual table.",
+    group: "text",
+    inputSchema: FtsCreateSchema,
+    outputSchema: FtsCreateOutputSchema,
+    requiredScopes: ["write"],
+    annotations: idempotent("FTS Create"),
+    handler: async (params, _context) => {
+      try {
+        const input = FtsCreateSchema.parse(params);
+        sanitizeIdentifier(input.tableName);
+        sanitizeIdentifier(input.sourceTable);
+        for (const col of input.columns) {
+          sanitizeIdentifier(col);
+        }
+        const columnList = input.columns.join(", ");
+        let options = `tokenize="${input.tokenizer}"`;
+        const effectiveContentTable = input.contentTable ?? input.sourceTable;
+        sanitizeIdentifier(effectiveContentTable);
+        options += `, content="${effectiveContentTable}"`;
+        const sql = `CREATE VIRTUAL TABLE IF NOT EXISTS "${input.tableName}" USING fts5(${columnList}, ${options})`;
+        await adapter.executeQuery(sql);
+        let triggersCreated = [];
+        if (input.createTriggers) {
+          triggersCreated = await createSyncTriggers(
+            adapter,
+            input.tableName,
+            effectiveContentTable,
+            input.columns
+          );
+        }
+        await adapter.executeQuery(
+          `INSERT INTO "${input.tableName}"("${input.tableName}") VALUES('rebuild')`
+        );
+        const message = triggersCreated.length ? `FTS5 table '${input.tableName}' created with ${triggersCreated.length} sync triggers` : `FTS5 table '${input.tableName}' created`;
+        return {
+          success: true,
+          message,
+          tableName: input.tableName,
+          triggersCreated: triggersCreated.length ? triggersCreated : void 0
+        };
+      } catch (error) {
+        if (isFts5UnavailableError(error)) {
+          return buildFts5UnavailableError(
+            params?.tableName
+          );
+        }
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+async function createSyncTriggers(adapter, ftsTable, contentTable, columns) {
+  const triggersCreated = [];
+  const colList = columns.map((c) => `"${c}"`).join(", ");
+  const newColList = columns.map((c) => `NEW."${c}"`).join(", ");
+  const oldColList = columns.map((c) => `OLD."${c}"`).join(", ");
+  const insertTriggerName = `${ftsTable}_ai`;
+  const insertTrigger = `
+    CREATE TRIGGER IF NOT EXISTS "${insertTriggerName}" AFTER INSERT ON "${contentTable}" BEGIN
+      INSERT INTO "${ftsTable}"(rowid, ${colList}) VALUES (NEW.rowid, ${newColList});
+    END;
+  `;
+  await adapter.executeQuery(insertTrigger);
+  triggersCreated.push(insertTriggerName);
+  const deleteTriggerName = `${ftsTable}_ad`;
+  const deleteTrigger = `
+    CREATE TRIGGER IF NOT EXISTS "${deleteTriggerName}" AFTER DELETE ON "${contentTable}" BEGIN
+      INSERT INTO "${ftsTable}"("${ftsTable}", rowid, ${colList}) VALUES('delete', OLD.rowid, ${oldColList});
+    END;
+  `;
+  await adapter.executeQuery(deleteTrigger);
+  triggersCreated.push(deleteTriggerName);
+  const updateTriggerName = `${ftsTable}_au`;
+  const updateTrigger = `
+    CREATE TRIGGER IF NOT EXISTS "${updateTriggerName}" AFTER UPDATE ON "${contentTable}" BEGIN
+      INSERT INTO "${ftsTable}"("${ftsTable}", rowid, ${colList}) VALUES('delete', OLD.rowid, ${oldColList});
+      INSERT INTO "${ftsTable}"(rowid, ${colList}) VALUES (NEW.rowid, ${newColList});
+    END;
+  `;
+  await adapter.executeQuery(updateTrigger);
+  triggersCreated.push(updateTriggerName);
+  return triggersCreated;
+}
+function createFtsSearchTool(adapter) {
+  return {
+    name: "sqlite_fts_search",
+    description: "Search an FTS5 table using full-text query syntax.",
+    group: "text",
+    inputSchema: FtsSearchSchema,
+    outputSchema: FtsSearchOutputSchema,
+    requiredScopes: ["read"],
+    annotations: readOnly("FTS Search"),
+    handler: async (params, _context) => {
+      try {
+        const input = FtsSearchSchema.parse(params);
+        if (!isFts5Available(adapter)) {
+          return buildFts5SearchUnavailableError();
+        }
+        sanitizeIdentifier(input.table);
+        await validateTableExists(adapter, input.table);
+        let selectClause = "*";
+        if (input.highlight) {
+          selectClause = `*, highlight("${input.table}", 0, '<b>', '</b>') as snippet`;
+        }
+        if (input.query === "*" || input.query.trim() === "") {
+          const sql2 = `SELECT ${selectClause}, NULL as rank FROM "${input.table}" ORDER BY rowid LIMIT ${input.limit}`;
+          const result2 = await adapter.executeReadQuery(sql2);
+          return {
+            success: true,
+            rowCount: result2.rows?.length ?? 0,
+            results: result2.rows
+          };
+        }
+        const queryEscaped = input.query.replace(/'/g, "''");
+        let matchExpr = `"${input.table}" MATCH '${queryEscaped}'`;
+        if (input.columns && input.columns.length > 0) {
+          for (const col of input.columns) {
+            sanitizeIdentifier(col);
+          }
+          const colFilter = input.columns.map((c) => `${c}:${queryEscaped}`).join(" OR ");
+          matchExpr = `"${input.table}" MATCH '${colFilter}'`;
+        }
+        const sql = `SELECT ${selectClause}, rank FROM "${input.table}" WHERE ${matchExpr} ORDER BY rank LIMIT ${input.limit}`;
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          success: true,
+          rowCount: result.rows?.length ?? 0,
+          results: result.rows
+        };
+      } catch (error) {
+        if (isFts5UnavailableError(error)) {
+          return buildFts5SearchUnavailableError();
+        }
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createFtsRebuildTool(adapter) {
+  return {
+    name: "sqlite_fts_rebuild",
+    description: "Rebuild an FTS5 index to optimize search performance.",
+    group: "text",
+    inputSchema: FtsRebuildSchema,
+    outputSchema: FtsRebuildOutputSchema,
+    requiredScopes: ["admin"],
+    annotations: admin("FTS Rebuild"),
+    handler: async (params, _context) => {
+      try {
+        const input = FtsRebuildSchema.parse(params);
+        if (!isFts5Available(adapter)) {
+          return buildFts5UnavailableError(input.table);
+        }
+        sanitizeIdentifier(input.table);
+        await validateTableExists(adapter, input.table);
+        const sql = `INSERT INTO "${input.table}"("${input.table}") VALUES('rebuild')`;
+        await adapter.executeQuery(sql);
+        return {
+          success: true,
+          message: `FTS5 index '${input.table}' rebuilt`,
+          tableName: input.table
+        };
+      } catch (error) {
+        if (isFts5UnavailableError(error)) {
+          return buildFts5UnavailableError(
+            params?.table
+          );
+        }
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createFtsMatchInfoTool(adapter) {
+  return {
+    name: "sqlite_fts_match_info",
+    description: "Get FTS5 match ranking information using bm25.",
+    group: "text",
+    inputSchema: FtsMatchInfoSchema,
+    outputSchema: FtsSearchOutputSchema,
+    requiredScopes: ["read"],
+    annotations: readOnly("FTS Match Info"),
+    handler: async (params, _context) => {
+      try {
+        const input = FtsMatchInfoSchema.parse(params);
+        if (!isFts5Available(adapter)) {
+          return buildFts5SearchUnavailableError();
+        }
+        sanitizeIdentifier(input.table);
+        await validateTableExists(adapter, input.table);
+        const queryEscaped = input.query.replace(/'/g, "''");
+        let rankExpr;
+        if (input.format === "bm25") {
+          rankExpr = `bm25("${input.table}")`;
+        } else {
+          rankExpr = "rank";
+        }
+        const sql = `SELECT *, ${rankExpr} as score FROM "${input.table}" WHERE "${input.table}" MATCH '${queryEscaped}' ORDER BY score`;
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          success: true,
+          rowCount: result.rows?.length ?? 0,
+          results: result.rows
+        };
+      } catch (error) {
+        if (isFts5UnavailableError(error)) {
+          return buildFts5SearchUnavailableError();
+        }
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+var VALID_MODES = ["deferred", "immediate", "exclusive"];
+var BeginTransactionSchema = z.object({
+  mode: z.preprocess(
+    (val) => {
+      if (typeof val !== "string") return void 0;
+      const normalized = val.toLowerCase();
+      return VALID_MODES.includes(normalized) ? normalized : void 0;
+    },
+    z.enum(["deferred", "immediate", "exclusive"]).optional().default("deferred").describe(
+      "Transaction mode: deferred waits for first write, immediate acquires lock immediately, exclusive blocks all access"
+    )
+  )
+});
+var SavepointSchema = z.object({
+  name: z.string().describe("Savepoint name")
+});
+var ExecuteInTransactionSchema = z.object({
+  statements: z.array(z.string()).describe("Array of SQL statements to execute in order"),
+  rollbackOnError: z.boolean().optional().default(true).describe("If true, rollback all changes when any statement fails")
+});
+function getTransactionTools(adapter) {
+  return [
+    createBeginTransactionTool(adapter),
+    createCommitTransactionTool(adapter),
+    createRollbackTransactionTool(adapter),
+    createSavepointTool(adapter),
+    createReleaseSavepointTool(adapter),
+    createRollbackToSavepointTool(adapter),
+    createExecuteInTransactionTool(adapter)
+  ];
+}
+function createBeginTransactionTool(adapter) {
+  return {
+    name: "sqlite_transaction_begin",
+    description: "Begin a new transaction. Use immediate or exclusive mode for write-heavy operations.",
+    group: "admin",
+    inputSchema: BeginTransactionSchema,
+    outputSchema: TransactionBeginOutputSchema,
+    annotations: write("Begin Transaction"),
+    requiredScopes: ["write"],
+    handler: async (params, _context) => {
+      try {
+        const input = BeginTransactionSchema.parse(params);
+        const mode = input.mode.toUpperCase();
+        await adapter.executeWriteQuery(`BEGIN ${mode} TRANSACTION`);
+        return {
+          success: true,
+          message: `Transaction started (${input.mode} mode)`,
+          mode: input.mode
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createCommitTransactionTool(adapter) {
+  return {
+    name: "sqlite_transaction_commit",
+    description: "Commit the current transaction, making all changes permanent.",
+    group: "admin",
+    inputSchema: z.object({}),
+    outputSchema: TransactionCommitOutputSchema,
+    annotations: write("Commit Transaction"),
+    requiredScopes: ["write"],
+    handler: (_params, _context) => {
+      try {
+        adapter.commitTransaction();
+        return Promise.resolve({
+          success: true,
+          message: "Transaction committed"
+        });
+      } catch (error) {
+        return Promise.resolve(formatHandlerError(error));
+      }
+    }
+  };
+}
+function createRollbackTransactionTool(adapter) {
+  return {
+    name: "sqlite_transaction_rollback",
+    description: "Rollback the current transaction, discarding all changes.",
+    group: "admin",
+    outputSchema: TransactionRollbackOutputSchema,
+    inputSchema: z.object({}),
+    annotations: write("Rollback Transaction"),
+    requiredScopes: ["write"],
+    handler: (_params, _context) => {
+      try {
+        adapter.rollbackTransaction();
+        return Promise.resolve({
+          success: true,
+          message: "Transaction rolled back"
+        });
+      } catch (error) {
+        return Promise.resolve(formatHandlerError(error));
+      }
+    }
+  };
+}
+function createSavepointTool(adapter) {
+  return {
+    name: "sqlite_transaction_savepoint",
+    description: "Create a savepoint within the current transaction for partial rollback.",
+    group: "admin",
+    outputSchema: TransactionSavepointOutputSchema,
+    inputSchema: SavepointSchema,
+    annotations: write("Create Savepoint"),
+    requiredScopes: ["write"],
+    handler: (params, _context) => {
+      try {
+        const input = SavepointSchema.parse(params);
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input.name)) {
+          return Promise.resolve(
+            formatHandlerError(
+              new ValidationError(
+                `Invalid savepoint name '${input.name}': must start with a letter or underscore and contain only alphanumeric characters`
+              )
+            )
+          );
+        }
+        adapter.savepoint(input.name);
+        return Promise.resolve({
+          success: true,
+          message: `Savepoint '${input.name}' created`,
+          savepoint: input.name
+        });
+      } catch (error) {
+        return Promise.resolve(formatHandlerError(error));
+      }
+    }
+  };
+}
+function createReleaseSavepointTool(adapter) {
+  return {
+    name: "sqlite_transaction_release",
+    description: "Release a savepoint, keeping the changes made since it was created.",
+    group: "admin",
+    inputSchema: SavepointSchema,
+    outputSchema: TransactionReleaseOutputSchema,
+    annotations: write("Release Savepoint"),
+    requiredScopes: ["write"],
+    handler: (params, _context) => {
+      try {
+        const input = SavepointSchema.parse(params);
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input.name)) {
+          return Promise.resolve(
+            formatHandlerError(
+              new ValidationError(
+                `Invalid savepoint name '${input.name}': must start with a letter or underscore and contain only alphanumeric characters`
+              )
+            )
+          );
+        }
+        adapter.releaseSavepoint(input.name);
+        return Promise.resolve({
+          success: true,
+          message: `Savepoint '${input.name}' released`,
+          savepoint: input.name
+        });
+      } catch (error) {
+        return Promise.resolve(formatHandlerError(error));
+      }
+    }
+  };
+}
+function createRollbackToSavepointTool(adapter) {
+  return {
+    name: "sqlite_transaction_rollback_to",
+    description: "Rollback to a savepoint, discarding changes made after it was created.",
+    group: "admin",
+    inputSchema: SavepointSchema,
+    outputSchema: TransactionRollbackToOutputSchema,
+    annotations: write("Rollback to Savepoint"),
+    requiredScopes: ["write"],
+    handler: (params, _context) => {
+      try {
+        const input = SavepointSchema.parse(params);
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input.name)) {
+          return Promise.resolve(
+            formatHandlerError(
+              new ValidationError(
+                `Invalid savepoint name '${input.name}': must start with a letter or underscore and contain only alphanumeric characters`
+              )
+            )
+          );
+        }
+        adapter.rollbackToSavepoint(input.name);
+        return Promise.resolve({
+          success: true,
+          message: `Rolled back to savepoint '${input.name}'`,
+          savepoint: input.name
+        });
+      } catch (error) {
+        return Promise.resolve(formatHandlerError(error));
+      }
+    }
+  };
+}
+function createExecuteInTransactionTool(adapter) {
+  return {
+    name: "sqlite_transaction_execute",
+    description: "Execute multiple SQL statements in a single transaction. Automatically commits on success or rolls back on error.",
+    group: "admin",
+    outputSchema: TransactionExecuteOutputSchema,
+    inputSchema: ExecuteInTransactionSchema,
+    annotations: write("Execute in Transaction"),
+    requiredScopes: ["write"],
+    handler: async (params, _context) => {
+      let input;
+      try {
+        input = ExecuteInTransactionSchema.parse(params);
+      } catch (error) {
+        return {
+          ...formatHandlerError(error),
+          message: "",
+          statementsExecuted: 0,
+          results: []
+        };
+      }
+      const results = [];
+      let success = true;
+      try {
+        adapter.beginTransaction();
+        for (const statement of input.statements) {
+          try {
+            const isSelect = statement.trim().toUpperCase().startsWith("SELECT");
+            if (isSelect) {
+              const result = await adapter.executeReadQuery(statement);
+              const rowCount = result.rows?.length ?? 0;
+              const statementResult = {
+                statement: statement.substring(0, 100) + (statement.length > 100 ? "..." : ""),
+                rowCount
+              };
+              if (result.rows) {
+                statementResult.rows = result.rows;
+              }
+              results.push(statementResult);
+            } else {
+              const result = await adapter.executeWriteQuery(statement);
+              results.push({
+                statement: statement.substring(0, 100) + (statement.length > 100 ? "..." : ""),
+                rowsAffected: result.rowsAffected ?? 0
+              });
+            }
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            results.push({
+              statement: statement.substring(0, 100) + (statement.length > 100 ? "..." : ""),
+              error: message
+            });
+            if (input.rollbackOnError) {
+              throw error;
+            }
+            success = false;
+          }
+        }
+        adapter.commitTransaction();
+        return {
+          success,
+          message: success ? "Transaction completed successfully" : "Transaction completed with errors",
+          statementsExecuted: input.statements.length,
+          results
+        };
+      } catch (error) {
+        let rollbackFailure;
+        try {
+          adapter.rollbackTransaction();
+        } catch (rbError) {
+          rollbackFailure = rbError instanceof Error ? rbError.message : String(rbError);
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        const formatted = formatHandlerError(error);
+        let rollbackMessage = `Transaction rolled back: ${message}`;
+        if (rollbackFailure) {
+          rollbackMessage += ` (rollback error: ${rollbackFailure})`;
+        }
+        return {
+          ...formatted,
+          error: formatted.error ?? rollbackMessage,
+          message: rollbackMessage,
+          statementsExecuted: results.length,
+          results
+        };
+      }
+    }
+  };
+}
+var coerceNumber = (val) => typeof val === "string" ? isNaN(Number(val)) ? void 0 : Number(val) : val;
+var coerceEnumValues2 = (allowed) => (val) => typeof val === "string" && allowed.includes(val) ? val : void 0;
+var VALID_DIRECTIONS = ["lag", "lead"];
+var RowNumberSchema = z.object({
+  table: z.string().describe("Table name"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  whereClause: z.string().optional().describe("Optional WHERE clause"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(100).describe("Maximum rows to return")
+  )
+});
+var RankSchema = z.object({
+  table: z.string().describe("Table name"),
+  orderBy: z.string().describe("Column(s) to order by (determines rank)"),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  rankType: z.preprocess(
+    coerceEnumValues2(["rank", "dense_rank", "percent_rank"]),
+    z.enum(["rank", "dense_rank", "percent_rank"]).optional().default("rank").describe("Rank function type")
+  ),
+  whereClause: z.string().optional().describe("Optional WHERE clause"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(100).describe("Maximum rows to return")
+  )
+});
+var LagLeadSchema = z.object({
+  table: z.string().describe("Table name"),
+  column: z.string().describe("Column to get lag/lead value from"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  direction: z.string().describe("LAG (previous) or LEAD (next) row"),
+  offset: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(1).describe("Number of rows to look back/ahead")
+  ),
+  defaultValue: z.string().optional().describe("Default value if no row exists"),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  whereClause: z.string().optional().describe("Optional WHERE clause"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(100).describe("Maximum rows to return")
+  )
+});
+var RunningTotalSchema = z.object({
+  table: z.string().describe("Table name"),
+  column: z.string().describe("Column to sum"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  partitionBy: z.string().optional().describe("Reset running total for each partition"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  whereClause: z.string().optional().describe("Optional WHERE clause"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(100).describe("Maximum rows to return")
+  )
+});
+var MovingAverageSchema = z.object({
+  table: z.string().describe("Table name"),
+  column: z.string().describe("Column to average"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  windowSize: z.preprocess(
+    coerceNumber,
+    z.number().optional().describe("Number of rows in the moving window")
+  ),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  whereClause: z.string().optional().describe("Optional WHERE clause"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(100).describe("Maximum rows to return")
+  )
+});
+var NtileSchema = z.object({
+  table: z.string().describe("Table name"),
+  orderBy: z.string().describe("Column(s) to order by"),
+  buckets: z.preprocess(
+    coerceNumber,
+    z.number().optional().describe("Number of buckets (e.g., 4 for quartiles)")
+  ),
+  partitionBy: z.string().optional().describe("Column(s) to partition by"),
+  selectColumns: z.array(z.string()).optional().describe("Columns to include in result"),
+  whereClause: z.string().optional().describe("Optional WHERE clause"),
+  limit: z.preprocess(
+    coerceNumber,
+    z.number().optional().default(100).describe("Maximum rows to return")
+  )
+});
+async function validateTableExists2(adapter, table) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(table)) {
+    throw new DbMcpError(
+      "Invalid table name",
+      "NATIVE_WINDOW_INVALID_TABLE",
+      "validation" /* VALIDATION */
+    );
+  }
+  const result = await adapter.executeReadQuery(
+    `SELECT 1 FROM sqlite_master WHERE type IN ('table', 'view') AND name='${table}'`
+  );
+  if (!result.rows || result.rows.length === 0) {
+    throw new ResourceNotFoundError(
+      `Table '${table}' does not exist`,
+      "TABLE_NOT_FOUND",
+      {
+        suggestion: "Table not found. Run sqlite_list_tables to see available tables.",
+        resourceType: "table",
+        resourceName: table
+      }
+    );
+  }
+}
+async function validateColumnInTable(adapter, table, column) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(column)) {
+    throw new DbMcpError(
+      "Invalid column name",
+      "NATIVE_WINDOW_INVALID_COLUMN",
+      "validation" /* VALIDATION */
+    );
+  }
+  const tableInfo = await adapter.executeReadQuery(
+    `SELECT name FROM pragma_table_info('${table}') WHERE name='${column}'`
+  );
+  if (!tableInfo.rows || tableInfo.rows.length === 0) {
+    throw new ResourceNotFoundError(
+      `Column '${column}' not found in table '${table}'`,
+      "COLUMN_NOT_FOUND",
+      {
+        suggestion: "Column not found. Use sqlite_describe_table to see available columns.",
+        resourceType: "column",
+        resourceName: column
+      }
+    );
+  }
+}
+async function validateOrderByColumns(adapter, table, orderBy) {
+  const parts = orderBy.split(",");
+  for (const part of parts) {
+    const tokens = part.trim().split(/\s+/);
+    const firstToken = tokens[0];
+    if (!firstToken) continue;
+    const colName = firstToken.replace(/^"|"$/g, "");
+    if (/[.()+*/]/.test(colName)) continue;
+    if (/^(ASC|DESC)$/i.test(colName)) continue;
+    await validateColumnInTable(adapter, table, colName);
+  }
+}
+function formatColumns(selectColumns) {
+  if (selectColumns === void 0 || selectColumns.length === 0) {
+    return "*";
+  }
+  return selectColumns.map((c) => `"${c}"`).join(", ");
+}
+function getWindowTools(adapter) {
+  return [
+    createRowNumberTool(adapter),
+    createRankTool(adapter),
+    createLagLeadTool(adapter),
+    createRunningTotalTool(adapter),
+    createMovingAverageTool(adapter),
+    createNtileTool(adapter)
+  ];
+}
+function createRowNumberTool(adapter) {
+  return {
+    name: "sqlite_window_row_number",
+    description: "Assign sequential row numbers based on ordering. Useful for pagination and ranking.",
+    group: "stats",
+    inputSchema: RowNumberSchema,
+    outputSchema: WindowRowNumberOutputSchema,
+    annotations: readOnly("Window Row Number"),
+    requiredScopes: ["read"],
+    handler: async (params, _context) => {
+      try {
+        const input = RowNumberSchema.parse(params);
+        await validateTableExists2(adapter, input.table);
+        await validateOrderByColumns(adapter, input.table, input.orderBy);
+        const columns = formatColumns(input.selectColumns);
+        const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
+        let sql = `
+                SELECT ${columns},
+                    ROW_NUMBER() OVER (${partition} ORDER BY ${input.orderBy}) as row_number
+                FROM "${input.table}"
+            `;
+        if (input.whereClause) {
+          validateWhereClause(input.whereClause);
+          sql += ` WHERE ${input.whereClause}`;
+        }
+        sql += ` LIMIT ${input.limit}`;
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          success: true,
+          rowCount: result.rows?.length ?? 0,
+          rows: result.rows
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createRankTool(adapter) {
+  return {
+    name: "sqlite_window_rank",
+    description: "Calculate rank of rows. RANK leaves gaps after ties, DENSE_RANK does not, PERCENT_RANK gives 0-1 range.",
+    group: "stats",
+    inputSchema: RankSchema,
+    outputSchema: WindowRankOutputSchema,
+    annotations: readOnly("Window Rank"),
+    requiredScopes: ["read"],
+    handler: async (params, _context) => {
+      try {
+        const input = RankSchema.parse(params);
+        await validateTableExists2(adapter, input.table);
+        await validateOrderByColumns(adapter, input.table, input.orderBy);
+        const columns = formatColumns(input.selectColumns);
+        const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
+        const rankFunc = input.rankType.toUpperCase();
+        let sql = `
+                SELECT ${columns},
+                    ${rankFunc}() OVER (${partition} ORDER BY ${input.orderBy}) as ${input.rankType}
+                FROM "${input.table}"
+            `;
+        if (input.whereClause) {
+          validateWhereClause(input.whereClause);
+          sql += ` WHERE ${input.whereClause}`;
+        }
+        sql += ` LIMIT ${input.limit}`;
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          success: true,
+          rankType: input.rankType,
+          rowCount: result.rows?.length ?? 0,
+          rows: result.rows
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createLagLeadTool(adapter) {
+  return {
+    name: "sqlite_window_lag_lead",
+    description: "Access previous (LAG) or next (LEAD) row values. Useful for comparing consecutive rows.",
+    group: "stats",
+    inputSchema: LagLeadSchema,
+    outputSchema: WindowLagLeadOutputSchema,
+    annotations: readOnly("Window Lag/Lead"),
+    requiredScopes: ["read"],
+    handler: async (params, _context) => {
+      try {
+        const input = LagLeadSchema.parse(params);
+        const normalizedDirection = input.direction.toLowerCase();
+        if (!VALID_DIRECTIONS.includes(
+          normalizedDirection
+        )) {
+          return {
+            success: false,
+            error: `Invalid direction '${input.direction}'. Must be one of: ${VALID_DIRECTIONS.join(", ")}`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        await validateTableExists2(adapter, input.table);
+        await validateColumnInTable(adapter, input.table, input.column);
+        await validateOrderByColumns(adapter, input.table, input.orderBy);
+        const columns = formatColumns(input.selectColumns);
+        const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
+        const func = normalizedDirection.toUpperCase();
+        const defaultVal = input.defaultValue !== void 0 ? `, ${input.defaultValue}` : "";
+        let sql = `
+                SELECT ${columns},
+                    ${func}("${input.column}", ${input.offset}${defaultVal}) OVER (${partition} ORDER BY ${input.orderBy}) as ${normalizedDirection}_value
+                FROM "${input.table}"
+            `;
+        if (input.whereClause) {
+          validateWhereClause(input.whereClause);
+          sql += ` WHERE ${input.whereClause}`;
+        }
+        sql += ` LIMIT ${input.limit}`;
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          success: true,
+          direction: normalizedDirection,
+          offset: input.offset,
+          rowCount: result.rows?.length ?? 0,
+          rows: result.rows
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createRunningTotalTool(adapter) {
+  return {
+    name: "sqlite_window_running_total",
+    description: "Calculate running (cumulative) total. Useful for balance tracking, cumulative metrics.",
+    group: "stats",
+    inputSchema: RunningTotalSchema,
+    outputSchema: WindowRunningTotalOutputSchema,
+    annotations: readOnly("Window Running Total"),
+    requiredScopes: ["read"],
+    handler: async (params, _context) => {
+      try {
+        const input = RunningTotalSchema.parse(
+          resolveAliases(params, { valueColumn: "column" })
+        );
+        await validateTableExists2(adapter, input.table);
+        await validateColumnInTable(adapter, input.table, input.column);
+        await validateOrderByColumns(adapter, input.table, input.orderBy);
+        const columns = formatColumns(input.selectColumns);
+        const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
+        let sql = `
+                SELECT ${columns},
+                    SUM("${input.column}") OVER (${partition} ORDER BY ${input.orderBy} ROWS UNBOUNDED PRECEDING) as running_total
+                FROM "${input.table}"
+            `;
+        if (input.whereClause) {
+          validateWhereClause(input.whereClause);
+          sql += ` WHERE ${input.whereClause}`;
+        }
+        sql += ` LIMIT ${input.limit}`;
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          success: true,
+          valueColumn: input.column,
+          rowCount: result.rows?.length ?? 0,
+          rows: result.rows
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createMovingAverageTool(adapter) {
+  return {
+    name: "sqlite_window_moving_avg",
+    description: "Calculate moving (rolling) average. Useful for smoothing time series data.",
+    group: "stats",
+    inputSchema: MovingAverageSchema,
+    outputSchema: WindowMovingAvgOutputSchema,
+    annotations: readOnly("Window Moving Average"),
+    requiredScopes: ["read"],
+    handler: async (params, _context) => {
+      try {
+        const input = MovingAverageSchema.parse(
+          resolveAliases(params, { valueColumn: "column" })
+        );
+        if (input.windowSize === void 0) {
+          return {
+            success: false,
+            error: "'windowSize' is required",
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        await validateTableExists2(adapter, input.table);
+        await validateColumnInTable(adapter, input.table, input.column);
+        await validateOrderByColumns(adapter, input.table, input.orderBy);
+        const columns = formatColumns(input.selectColumns);
+        const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
+        const preceding = input.windowSize - 1;
+        let sql = `
+                SELECT ${columns},
+                    AVG("${input.column}") OVER (${partition} ORDER BY ${input.orderBy} ROWS BETWEEN ${preceding} PRECEDING AND CURRENT ROW) as moving_avg
+                FROM "${input.table}"
+            `;
+        if (input.whereClause) {
+          validateWhereClause(input.whereClause);
+          sql += ` WHERE ${input.whereClause}`;
+        }
+        sql += ` LIMIT ${input.limit}`;
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          success: true,
+          valueColumn: input.column,
+          windowSize: input.windowSize,
+          rowCount: result.rows?.length ?? 0,
+          rows: result.rows
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createNtileTool(adapter) {
+  return {
+    name: "sqlite_window_ntile",
+    description: "Divide rows into N buckets. E.g., 4 buckets = quartiles, 10 = deciles, 100 = percentiles.",
+    group: "stats",
+    inputSchema: NtileSchema,
+    outputSchema: WindowNtileOutputSchema,
+    annotations: readOnly("Window Ntile"),
+    requiredScopes: ["read"],
+    handler: async (params, _context) => {
+      try {
+        const input = NtileSchema.parse(params);
+        if (input.buckets === void 0) {
+          return {
+            success: false,
+            error: "'buckets' is required",
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        await validateTableExists2(adapter, input.table);
+        await validateOrderByColumns(adapter, input.table, input.orderBy);
+        const columns = formatColumns(input.selectColumns);
+        const partition = input.partitionBy ? `PARTITION BY ${input.partitionBy}` : "";
+        let sql = `
+                SELECT ${columns},
+                    NTILE(${input.buckets}) OVER (${partition} ORDER BY ${input.orderBy}) as ntile
+                FROM "${input.table}"
+            `;
+        if (input.whereClause) {
+          validateWhereClause(input.whereClause);
+          sql += ` WHERE ${input.whereClause}`;
+        }
+        sql += ` LIMIT ${input.limit}`;
+        const result = await adapter.executeReadQuery(sql);
+        return {
+          success: true,
+          buckets: input.buckets,
+          rowCount: result.rows?.length ?? 0,
+          rows: result.rows
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+var coerceNumber2 = (val) => typeof val === "string" ? isNaN(Number(val)) ? void 0 : Number(val) : val;
+var coerceBoolean = (val) => typeof val === "string" ? val === "true" ? true : val === "false" ? false : void 0 : val;
+function createEnumCoercer(validValues) {
+  return (val) => typeof val === "string" && validValues.includes(val) ? val : typeof val === "string" ? void 0 : val;
+}
+var VALID_GEOMETRY_TYPES = [
+  "POINT",
+  "LINESTRING",
+  "POLYGON",
+  "MULTIPOINT",
+  "MULTILINESTRING",
+  "MULTIPOLYGON",
+  "GEOMETRY"
+];
+var VALID_ANALYSIS_TYPES = [
+  "nearest_neighbor",
+  "point_in_polygon",
+  "distance_matrix",
+  "spatial_extent"
+];
+var VALID_INDEX_ACTIONS = ["create", "drop", "check"];
+var VALID_FORMATS = ["wkt", "geojson"];
+var VALID_OPERATIONS = [
+  "buffer",
+  "intersection",
+  "union",
+  "difference",
+  "centroid",
+  "envelope",
+  "simplify"
+];
+var coerceGeometryType = createEnumCoercer(VALID_GEOMETRY_TYPES);
+var LoadSpatialiteSchema = z.object({
+  extensionPath: z.string().optional().describe("Custom path to mod_spatialite extension"),
+  forceReload: z.preprocess(
+    coerceBoolean,
+    z.boolean().optional().default(false).describe("Force reload if already loaded")
+  )
+});
+var CreateSpatialTableSchema = z.object({
+  tableName: z.string().describe("Name of the spatial table to create"),
+  geometryColumn: z.string().optional().default("geom").describe("Name of the geometry column"),
+  geometryType: z.preprocess(
+    coerceGeometryType,
+    z.enum([
+      "POINT",
+      "LINESTRING",
+      "POLYGON",
+      "MULTIPOINT",
+      "MULTILINESTRING",
+      "MULTIPOLYGON",
+      "GEOMETRY"
+    ]).optional().default("POINT").describe("Type of geometry to store")
+  ),
+  srid: z.preprocess(
+    coerceNumber2,
+    z.number().optional().default(4326).describe("Spatial Reference System ID (4326 for WGS84)")
+  ),
+  additionalColumns: z.array(
+    z.object({
+      name: z.string(),
+      type: z.string()
+    })
+  ).optional().default([]).describe("Additional non-spatial columns")
+});
+var SpatialQuerySchema = z.object({
+  query: z.string().describe("Spatial SQL query using SpatiaLite functions"),
+  params: z.array(z.unknown()).optional().default([]).describe("Query parameters")
+});
+var SpatialAnalysisSchema = z.object({
+  analysisType: z.string().describe(
+    "Type of spatial analysis: nearest_neighbor, point_in_polygon, distance_matrix, spatial_extent"
+  ),
+  sourceTable: z.string().describe("Source table for analysis"),
+  targetTable: z.string().optional().describe(
+    "Target table for operations. For point_in_polygon, this should contain POLYGON geometries while sourceTable contains POINTs"
+  ),
+  geometryColumn: z.string().optional().default("geom").describe("Geometry column name"),
+  limit: z.preprocess(
+    coerceNumber2,
+    z.number().optional().default(100).describe("Limit results")
+  ),
+  excludeSelf: z.preprocess(
+    coerceBoolean,
+    z.boolean().optional().default(true).describe(
+      "For nearest_neighbor: exclude self-matches when source and target tables are the same (default: true)"
+    )
+  ),
+  includeGeometry: z.preprocess(
+    coerceBoolean,
+    z.boolean().optional().default(false).describe(
+      "Include full WKT geometry in results (default: false to reduce payload size)"
+    )
+  )
+});
+var SpatialIndexSchema = z.object({
+  tableName: z.string().describe("Name of the spatial table"),
+  geometryColumn: z.string().optional().default("geom").describe("Geometry column name"),
+  action: z.string().optional().default("create").describe("Action to perform: create, drop, check")
+});
+var GeometryTransformSchema = z.object({
+  operation: z.string().describe(
+    "Geometry operation: buffer, intersection, union, difference, centroid, envelope, simplify"
+  ),
+  geometry1: z.string().describe("First geometry (WKT format)"),
+  geometry2: z.string().optional().describe("Second geometry for binary ops"),
+  distance: z.preprocess(
+    coerceNumber2,
+    z.number().optional().default(1e-3).describe("Distance for buffer or simplify tolerance")
+  ),
+  srid: z.preprocess(
+    coerceNumber2,
+    z.number().optional().default(4326).describe("SRID for result")
+  ),
+  simplifyTolerance: z.preprocess(
+    coerceNumber2,
+    z.number().optional().describe(
+      "For buffer operation: apply ST_Simplify to reduce vertices in output polygon. Recommended: 0.0001-0.001 for lat/lon"
+    )
+  )
+});
+var SpatialImportSchema = z.object({
+  tableName: z.string().describe("Target table name"),
+  format: z.string().describe("Input format: wkt or geojson"),
+  data: z.string().describe("Geometry data (WKT string or GeoJSON)"),
+  srid: z.preprocess(
+    coerceNumber2,
+    z.number().optional().default(4326).describe("SRID of input data")
+  ),
+  additionalData: z.record(z.string(), z.unknown()).optional().describe("Additional column values")
+});
+
+// src/adapters/sqlite-native/tools/spatialite/loader.ts
+var SPATIALITE_PATHS = [
+  process.env["SPATIALITE_PATH"],
+  "mod_spatialite",
+  "mod_spatialite.dll",
+  "mod_spatialite.so",
+  "/usr/lib/x86_64-linux-gnu/mod_spatialite.so",
+  "/usr/local/lib/mod_spatialite.so",
+  "/usr/local/lib/mod_spatialite.dylib"
+].filter((p) => Boolean(p));
+var loadedDatabases = /* @__PURE__ */ new WeakSet();
+function tryLoadSpatialite(adapter, customPath) {
+  const db = adapter.getDatabase();
+  if (db === null) {
+    return { success: false, error: "Database not connected" };
+  }
+  const paths = customPath ? [customPath, ...SPATIALITE_PATHS] : SPATIALITE_PATHS;
+  const chosenPathForEnv = customPath ?? process.env["SPATIALITE_PATH"];
+  if (process.platform === "win32" && chosenPathForEnv) {
+    const looksLikeFsPath = chosenPathForEnv.includes("/") || chosenPathForEnv.includes("\\");
+    if (looksLikeFsPath) {
+      const extensionDir = chosenPathForEnv.replace(/[/\\][^/\\]+$/, "");
+      const currentPath = process.env["PATH"] ?? "";
+      if (!currentPath.includes(extensionDir)) {
+        process.env["PATH"] = extensionDir + ";" + currentPath;
+      }
+    }
+  }
+  for (const candidatePath of paths) {
+    try {
+      db.loadExtension(candidatePath);
+      db.exec("SELECT InitSpatialMetaData(1)");
+      loadedDatabases.add(db);
+      return { success: true, path: candidatePath };
+    } catch {
+    }
+  }
+  return {
+    success: false,
+    error: "SpatiaLite extension not found. Install mod_spatialite and set SPATIALITE_PATH environment variable."
+  };
+}
+function isSpatialiteLoaded(adapter) {
+  const db = adapter.getDatabase();
+  if (db === null) return false;
+  if (loadedDatabases.has(db)) return true;
+  try {
+    db.exec("SELECT spatialite_version()");
+    db.exec("SELECT InitSpatialMetaData(1)");
+    loadedDatabases.add(db);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function ensureSpatialite(adapter) {
+  if (!isSpatialiteLoaded(adapter)) {
+    const result = tryLoadSpatialite(adapter);
+    if (!result.success) {
+      throw new DbMcpError(
+        result.error ?? "Failed to load SpatiaLite",
+        "SPATIALITE_LOAD_FAILED",
+        "connection" /* CONNECTION */
+      );
+    }
+  }
+}
+
+// src/adapters/sqlite-native/tools/spatialite/tools.ts
+function createLoadSpatialiteTool(adapter) {
+  return {
+    name: "sqlite_spatialite_load",
+    description: "Load SpatiaLite extension for geospatial capabilities. Required before using other spatial tools.",
+    group: "geo",
+    inputSchema: LoadSpatialiteSchema,
+    outputSchema: SpatialiteLoadOutputSchema,
+    requiredScopes: ["admin"],
+    annotations: admin("SpatiaLite Load"),
+    handler: (_params, _context) => {
+      try {
+        const input = LoadSpatialiteSchema.parse(_params);
+        if (!input.forceReload && isSpatialiteLoaded(adapter)) {
+          return Promise.resolve({
+            success: true,
+            message: "SpatiaLite already loaded",
+            alreadyLoaded: true
+          });
+        }
+        const result = tryLoadSpatialite(adapter, input.extensionPath);
+        if (result.success) {
+          return Promise.resolve({
+            success: true,
+            message: "SpatiaLite loaded successfully",
+            extensionPath: result.path
+          });
+        }
+        return Promise.resolve({
+          success: false,
+          error: result.error,
+          code: "SPATIALITE_LOAD_FAILED",
+          category: "internal",
+          recoverable: false,
+          searchedPaths: SPATIALITE_PATHS
+        });
+      } catch (error) {
+        return Promise.resolve(formatHandlerError(error));
+      }
+    }
+  };
+}
+function createSpatialTableTool(adapter) {
+  return {
+    name: "sqlite_spatialite_create_table",
+    description: "Create a spatial table with geometry column using SpatiaLite.",
+    group: "geo",
+    inputSchema: CreateSpatialTableSchema,
+    outputSchema: SpatialiteCreateTableOutputSchema,
+    requiredScopes: ["write"],
+    annotations: write("SpatiaLite Create Table"),
+    handler: async (params, _context) => {
+      try {
+        const input = CreateSpatialTableSchema.parse(params);
+        ensureSpatialite(adapter);
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input.tableName)) {
+          return {
+            success: false,
+            error: `Invalid table name: '${input.tableName}'`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        const existsCheck = await adapter.executeReadQuery(
+          `SELECT name FROM sqlite_master WHERE type='table' AND name='${input.tableName}'`
+        );
+        const alreadyExists = existsCheck.rows != null && existsCheck.rows.length > 0;
+        if (alreadyExists) {
+          return {
+            success: true,
+            message: `Spatial table '${input.tableName}' already exists`,
+            alreadyExists: true,
+            tableName: input.tableName
+          };
+        }
+        const columns = ["id INTEGER PRIMARY KEY AUTOINCREMENT"];
+        for (const col of input.additionalColumns) {
+          if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(col.name)) {
+            return {
+              success: false,
+              error: `Invalid column name: '${col.name}'`,
+              code: "VALIDATION_ERROR",
+              category: "validation",
+              recoverable: false
+            };
+          }
+          columns.push(`"${col.name}" ${col.type}`);
+        }
+        await adapter.executeWriteQuery(
+          `CREATE TABLE "${input.tableName}" (${columns.join(", ")})`
+        );
+        const addResult = await adapter.executeReadQuery(
+          `SELECT AddGeometryColumn('${input.tableName}', '${input.geometryColumn}', ${input.srid}, '${input.geometryType}', 'XY')`
+        );
+        const verifyResult = await adapter.executeReadQuery(
+          `SELECT name FROM pragma_table_info('${input.tableName}') WHERE name = '${input.geometryColumn}'`
+        );
+        if (!verifyResult.rows || verifyResult.rows.length === 0) {
+          return {
+            success: false,
+            error: `Failed to create geometry column '${input.geometryColumn}'. AddGeometryColumn returned: ${JSON.stringify(addResult.rows)}`,
+            code: "SPATIALITE_CREATE_FAILED",
+            category: "internal",
+            recoverable: false
+          };
+        }
+        return {
+          success: true,
+          message: `Spatial table '${input.tableName}' created`,
+          tableName: input.tableName,
+          geometryColumn: input.geometryColumn,
+          geometryType: input.geometryType,
+          srid: input.srid
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createSpatialQueryTool(adapter) {
+  return {
+    name: "sqlite_spatialite_query",
+    description: "Execute spatial SQL queries using SpatiaLite functions (ST_Distance, ST_Within, etc.).",
+    group: "geo",
+    inputSchema: SpatialQuerySchema,
+    outputSchema: SpatialiteQueryOutputSchema,
+    requiredScopes: ["read"],
+    annotations: readOnly("SpatiaLite Query"),
+    handler: async (params, _context) => {
+      try {
+        const input = SpatialQuerySchema.parse(params);
+        ensureSpatialite(adapter);
+        const result = await adapter.executeReadQuery(input.query);
+        return {
+          success: true,
+          rowCount: result.rows?.length ?? 0,
+          rows: result.rows
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (msg.includes("does not return data")) {
+          return {
+            success: false,
+            error: "This tool only supports SELECT queries. Use sqlite_write_query for INSERT/UPDATE/DELETE statements.",
+            code: "QUERY_NOT_SELECT",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createSpatialIndexTool(adapter) {
+  return {
+    name: "sqlite_spatialite_index",
+    description: "Create, drop, or check spatial R-Tree index on geometry column.",
+    group: "geo",
+    inputSchema: SpatialIndexSchema,
+    outputSchema: SpatialiteIndexOutputSchema,
+    requiredScopes: ["write"],
+    annotations: write("SpatiaLite Index"),
+    handler: async (params, _context) => {
+      try {
+        const input = SpatialIndexSchema.parse(params);
+        ensureSpatialite(adapter);
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input.tableName)) {
+          return {
+            success: false,
+            error: `Invalid table name: '${input.tableName}'`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        if (!VALID_INDEX_ACTIONS.includes(input.action)) {
+          return {
+            success: false,
+            error: `Invalid action: '${input.action}'. Must be one of: ${VALID_INDEX_ACTIONS.join(", ")}`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        const tableCheck = await adapter.executeReadQuery(
+          `SELECT name FROM sqlite_master WHERE type='table' AND name='${input.tableName}'`
+        );
+        if (!tableCheck.rows || tableCheck.rows.length === 0) {
+          return {
+            success: false,
+            error: `Table '${input.tableName}' does not exist`,
+            code: "TABLE_NOT_FOUND",
+            category: "resource",
+            suggestion: "Table not found. Run sqlite_list_tables to see available tables.",
+            recoverable: false
+          };
+        }
+        const indexExists = async () => {
+          const idxCheck = await adapter.executeReadQuery(
+            `SELECT name FROM sqlite_master WHERE type='table' AND name='idx_${input.tableName}_${input.geometryColumn}'`
+          );
+          return (idxCheck.rows?.length ?? 0) > 0;
+        };
+        switch (input.action) {
+          case "create": {
+            if (await indexExists()) {
+              return {
+                success: true,
+                message: `Spatial index already exists on ${input.tableName}.${input.geometryColumn}`,
+                alreadyExists: true,
+                action: "create"
+              };
+            }
+            await adapter.executeReadQuery(
+              `SELECT CreateSpatialIndex('${input.tableName}', '${input.geometryColumn}')`
+            );
+            return {
+              success: true,
+              message: `Spatial index created on ${input.tableName}.${input.geometryColumn}`,
+              action: "create"
+            };
+          }
+          case "drop": {
+            if (!await indexExists()) {
+              return {
+                success: true,
+                message: `No spatial index exists on ${input.tableName}.${input.geometryColumn}`,
+                alreadyDropped: true,
+                action: "drop"
+              };
+            }
+            await adapter.executeReadQuery(
+              `SELECT DisableSpatialIndex('${input.tableName}', '${input.geometryColumn}')`
+            );
+            return {
+              success: true,
+              message: `Spatial index dropped from ${input.tableName}.${input.geometryColumn}`,
+              action: "drop"
+            };
+          }
+          case "check": {
+            const hasIndex = await indexExists();
+            if (!hasIndex) {
+              return {
+                success: true,
+                message: "No spatial index found",
+                action: "check",
+                indexed: false
+              };
+            }
+            const checkResult = await adapter.executeReadQuery(
+              `SELECT CheckSpatialIndex('${input.tableName}', '${input.geometryColumn}')`
+            );
+            const checkValue = checkResult.rows?.[0];
+            const rawResult = checkValue != null ? Object.values(checkValue)[0] : null;
+            if (rawResult === 1) {
+              return {
+                success: true,
+                message: "Spatial index is valid",
+                action: "check",
+                indexed: true,
+                valid: true
+              };
+            } else if (rawResult === 0) {
+              return {
+                success: true,
+                message: "Spatial index exists but is invalid (rebuild recommended)",
+                action: "check",
+                indexed: true,
+                valid: false
+              };
+            } else {
+              return {
+                success: true,
+                message: "Spatial index exists (validation inconclusive \u2014 common in SpatiaLite 5.x)",
+                action: "check",
+                indexed: true,
+                valid: null
+              };
+            }
+          }
+          default:
+            return {
+              success: false,
+              error: `Invalid action: '${input.action}'. Must be one of: ${VALID_INDEX_ACTIONS.join(", ")}`,
+              code: "VALIDATION_ERROR",
+              category: "validation",
+              recoverable: false
+            };
+        }
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+
+// src/adapters/sqlite-native/tools/spatialite/analysis.ts
+function createSpatialAnalysisTool(adapter) {
+  return {
+    name: "sqlite_spatialite_analyze",
+    description: "Perform spatial analysis: nearest neighbor, point in polygon, distance matrix. For point_in_polygon, sourceTable should contain POINTs and targetTable should contain POLYGONs.",
+    group: "geo",
+    inputSchema: SpatialAnalysisSchema,
+    outputSchema: SpatialiteAnalyzeOutputSchema,
+    requiredScopes: ["read"],
+    annotations: readOnly("SpatiaLite Analyze"),
+    handler: async (params, _context) => {
+      try {
+        const input = SpatialAnalysisSchema.parse(params);
+        ensureSpatialite(adapter);
+        if (!VALID_ANALYSIS_TYPES.includes(
+          input.analysisType
+        )) {
+          return {
+            success: false,
+            error: `Invalid analysisType: '${input.analysisType}'. Must be one of: ${VALID_ANALYSIS_TYPES.join(", ")}`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input.sourceTable)) {
+          return {
+            success: false,
+            error: `Invalid source table name: '${input.sourceTable}'`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        if (input.targetTable && !/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input.targetTable)) {
+          return {
+            success: false,
+            error: `Invalid target table name: '${input.targetTable}'`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        let query;
+        switch (input.analysisType) {
+          case "spatial_extent":
+            query = `SELECT
+              MbrMinX(Extent("${input.geometryColumn}")) as min_x,
+              MbrMinY(Extent("${input.geometryColumn}")) as min_y,
+              MbrMaxX(Extent("${input.geometryColumn}")) as max_x,
+              MbrMaxY(Extent("${input.geometryColumn}")) as max_y,
+              COUNT(*) as feature_count
+            FROM "${input.sourceTable}"`;
+            break;
+          case "nearest_neighbor": {
+            if (!input.targetTable) {
+              return {
+                success: false,
+                error: "Missing required parameter 'targetTable' for nearest neighbor analysis",
+                code: "VALIDATION_ERROR",
+                category: "validation",
+                recoverable: false
+              };
+            }
+            const sameTable = input.sourceTable === input.targetTable;
+            const selfFilter = sameTable && input.excludeSelf ? "WHERE s.id != t.id" : "";
+            const geomColumns = input.includeGeometry ? `, AsText(s."${input.geometryColumn}") as source_geom, AsText(t."${input.geometryColumn}") as target_geom` : "";
+            query = `SELECT
+              s.id as source_id, t.id as target_id,
+              ST_Distance(s."${input.geometryColumn}", t."${input.geometryColumn}") as distance${geomColumns}
+            FROM "${input.sourceTable}" s, "${input.targetTable}" t
+            ${selfFilter}
+            ORDER BY distance LIMIT ${input.limit}`;
+            break;
+          }
+          case "point_in_polygon": {
+            if (!input.targetTable) {
+              return {
+                success: false,
+                error: "Missing required parameter 'targetTable' for point in polygon analysis",
+                code: "VALIDATION_ERROR",
+                category: "validation",
+                recoverable: false
+              };
+            }
+            const geomCols = input.includeGeometry ? `, AsText(s."${input.geometryColumn}") as source_geom, AsText(t."${input.geometryColumn}") as target_geom` : "";
+            query = `SELECT
+              s.id as source_id, t.id as target_id${geomCols}
+            FROM "${input.sourceTable}" s, "${input.targetTable}" t
+            WHERE ST_Within(s."${input.geometryColumn}", t."${input.geometryColumn}")
+            LIMIT ${input.limit}`;
+            break;
+          }
+          case "distance_matrix": {
+            const dmTarget = input.targetTable ?? input.sourceTable;
+            const dmSameTable = dmTarget === input.sourceTable;
+            const dmFilter = dmSameTable ? "WHERE a.id < b.id" : "";
+            query = `SELECT a.id as id1, b.id as id2,
+              ST_Distance(a."${input.geometryColumn}", b."${input.geometryColumn}") as distance
+            FROM "${input.sourceTable}" a, "${dmTarget}" b
+            ${dmFilter}
+            ORDER BY distance LIMIT ${input.limit}`;
+            break;
+          }
+          default:
+            query = "SELECT 1";
+        }
+        const result = await adapter.executeReadQuery(query);
+        return {
+          success: true,
+          analysisType: input.analysisType,
+          rowCount: result.rows?.length ?? 0,
+          results: result.rows
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createGeometryTransformTool(adapter) {
+  return {
+    name: "sqlite_spatialite_transform",
+    description: "Perform geometry operations: buffer, intersection, union, centroid, simplify.",
+    group: "geo",
+    inputSchema: GeometryTransformSchema,
+    outputSchema: SpatialiteTransformOutputSchema,
+    requiredScopes: ["read"],
+    annotations: readOnly("SpatiaLite Transform"),
+    handler: async (params, _context) => {
+      try {
+        const input = GeometryTransformSchema.parse(params);
+        ensureSpatialite(adapter);
+        if (!VALID_OPERATIONS.includes(input.operation)) {
+          return {
+            success: false,
+            error: `Invalid operation: '${input.operation}'. Must be one of: ${VALID_OPERATIONS.join(", ")}`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        let query;
+        switch (input.operation) {
+          case "buffer": {
+            const bufferGeom = `Buffer(GeomFromText('${input.geometry1}', ${input.srid}), ${input.distance})`;
+            const defaultTolerance = Math.max(1e-4, input.distance * 0.01);
+            const tolerance = input.simplifyTolerance ?? defaultTolerance;
+            const finalGeom = tolerance > 0 ? `Simplify(${bufferGeom}, ${tolerance})` : bufferGeom;
+            query = `SELECT AsText(${finalGeom}) as result`;
+            break;
+          }
+          case "intersection":
+            if (!input.geometry2) {
+              return {
+                success: false,
+                error: "Second geometry required for intersection",
+                code: "VALIDATION_ERROR",
+                category: "validation",
+                recoverable: false
+              };
+            }
+            query = `SELECT AsText(Intersection(
+              GeomFromText('${input.geometry1}', ${input.srid}),
+              GeomFromText('${input.geometry2}', ${input.srid})
+            )) as result`;
+            break;
+          case "union":
+            if (!input.geometry2) {
+              return {
+                success: false,
+                error: "Second geometry required for union",
+                code: "VALIDATION_ERROR",
+                category: "validation",
+                recoverable: false
+              };
+            }
+            query = `SELECT AsText(GUnion(
+              GeomFromText('${input.geometry1}', ${input.srid}),
+              GeomFromText('${input.geometry2}', ${input.srid})
+            )) as result`;
+            break;
+          case "difference":
+            if (!input.geometry2) {
+              return {
+                success: false,
+                error: "Second geometry required for difference",
+                code: "VALIDATION_ERROR",
+                category: "validation",
+                recoverable: false
+              };
+            }
+            query = `SELECT AsText(Difference(
+              GeomFromText('${input.geometry1}', ${input.srid}),
+              GeomFromText('${input.geometry2}', ${input.srid})
+            )) as result`;
+            break;
+          case "centroid":
+            query = `SELECT AsText(Centroid(GeomFromText('${input.geometry1}', ${input.srid}))) as result`;
+            break;
+          case "envelope":
+            query = `SELECT AsText(Envelope(GeomFromText('${input.geometry1}', ${input.srid}))) as result`;
+            break;
+          case "simplify":
+            query = `SELECT AsText(Simplify(GeomFromText('${input.geometry1}', ${input.srid}), ${input.distance})) as result`;
+            break;
+          default:
+            query = "SELECT 1";
+        }
+        const result = await adapter.executeReadQuery(query);
+        const wktResult = result.rows?.[0]?.["result"];
+        if (wktResult === null || wktResult === void 0) {
+          return {
+            success: false,
+            error: `Invalid geometry: '${input.geometry1}' could not be parsed as WKT`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        return {
+          success: true,
+          operation: input.operation,
+          result: wktResult
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+function createSpatialImportTool(adapter) {
+  return {
+    name: "sqlite_spatialite_import",
+    description: "Import geometry data from WKT or GeoJSON into a spatial table.",
+    group: "geo",
+    inputSchema: SpatialImportSchema,
+    outputSchema: SpatialiteImportOutputSchema,
+    requiredScopes: ["write"],
+    annotations: write("SpatiaLite Import"),
+    handler: async (params, _context) => {
+      try {
+        const input = SpatialImportSchema.parse(params);
+        ensureSpatialite(adapter);
+        if (!VALID_FORMATS.includes(input.format)) {
+          return {
+            success: false,
+            error: `Invalid format: '${input.format}'. Must be one of: ${VALID_FORMATS.join(", ")}`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(input.tableName)) {
+          return {
+            success: false,
+            error: `Invalid table name: '${input.tableName}'`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        let wkt;
+        if (input.format === "geojson") {
+          try {
+            JSON.parse(input.data);
+            const columns2 = ["geom"];
+            const values2 = [
+              `SetSRID(GeomFromGeoJSON('${input.data}'), ${input.srid})`
+            ];
+            if (input.additionalData) {
+              for (const [key, value] of Object.entries(input.additionalData)) {
+                if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+                  return {
+                    success: false,
+                    error: `Invalid column name: '${key}'`,
+                    code: "VALIDATION_ERROR",
+                    category: "validation",
+                    recoverable: false
+                  };
+                }
+                columns2.push(`"${key}"`);
+                values2.push(
+                  typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : String(value)
+                );
+              }
+            }
+            const sql2 = `INSERT INTO "${input.tableName}" (${columns2.join(", ")}) VALUES (${values2.join(", ")})`;
+            const insertResult2 = await adapter.executeWriteQuery(sql2);
+            return {
+              success: true,
+              message: "GeoJSON geometry imported",
+              rowsAffected: insertResult2.rowsAffected ?? 1
+            };
+          } catch (e) {
+            return {
+              success: false,
+              error: `Invalid GeoJSON: ${e instanceof Error ? e.message : String(e)}`,
+              code: "VALIDATION_ERROR",
+              category: "validation",
+              recoverable: false
+            };
+          }
+        } else {
+          wkt = input.data;
+        }
+        const wktCheck = await adapter.executeReadQuery(
+          `SELECT GeomFromText('${wkt}', ${input.srid}) as geom`
+        );
+        const parsedGeom = wktCheck.rows?.[0]?.["geom"];
+        if (parsedGeom === null || parsedGeom === void 0) {
+          return {
+            success: false,
+            error: `Invalid WKT geometry: '${wkt}' could not be parsed`,
+            code: "VALIDATION_ERROR",
+            category: "validation",
+            recoverable: false
+          };
+        }
+        const columns = ["geom"];
+        const values = [`GeomFromText('${wkt}', ${input.srid})`];
+        if (input.additionalData) {
+          for (const [key, value] of Object.entries(input.additionalData)) {
+            if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key)) {
+              return {
+                success: false,
+                error: `Invalid column name: '${key}'`,
+                code: "VALIDATION_ERROR",
+                category: "validation",
+                recoverable: false
+              };
+            }
+            columns.push(`"${key}"`);
+            values.push(
+              typeof value === "string" ? `'${value.replace(/'/g, "''")}'` : String(value)
+            );
+          }
+        }
+        const sql = `INSERT INTO "${input.tableName}" (${columns.join(", ")}) VALUES (${values.join(", ")})`;
+        const insertResult = await adapter.executeWriteQuery(sql);
+        return {
+          success: true,
+          message: "WKT geometry imported",
+          rowsAffected: insertResult.rowsAffected ?? 1
+        };
+      } catch (error) {
+        return formatHandlerError(error);
+      }
+    }
+  };
+}
+
+// src/adapters/sqlite-native/tools/spatialite/index.ts
+function getSpatialiteTools(adapter) {
+  return [
+    createLoadSpatialiteTool(adapter),
+    createSpatialTableTool(adapter),
+    createSpatialQueryTool(adapter),
+    createSpatialAnalysisTool(adapter),
+    createSpatialIndexTool(adapter),
+    createGeometryTransformTool(adapter),
+    createSpatialImportTool(adapter)
+  ];
+}
+
+// src/adapters/sqlite-native/registration/index.ts
+function getNativeToolDefinitions(adapter) {
+  const sharedAdapter = adapter;
+  const tools = [
+    ...getCoreTools(sharedAdapter),
+    ...getJsonOperationTools(sharedAdapter),
+    ...getJsonHelperTools(sharedAdapter),
+    ...getTextTools(sharedAdapter),
+    ...getFtsTools(sharedAdapter),
+    ...getStatsTools(sharedAdapter),
+    ...getVirtualTools(sharedAdapter),
+    ...getVectorTools(sharedAdapter),
+    ...getGeoTools(sharedAdapter),
+    ...getAdminTools(sharedAdapter),
+    ...getIntrospectionTools(sharedAdapter),
+    ...getMigrationTools(sharedAdapter),
+    ...getCodeModeTools(sharedAdapter),
+    // Native-only tools
+    ...getTransactionTools(adapter),
+    ...getWindowTools(adapter),
+    ...getSpatialiteTools(adapter)
+  ];
+  for (const tool of tools) {
+    if (!tool.icons) {
+      const icons = getToolGroupIcon(tool.group);
+      if (icons) {
+        tool.icons = icons;
+      }
+    }
+  }
+  return tools;
+}
+function findProjectRoot(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 10; i++) {
+    if (fs.existsSync(path.join(dir, "package.json"))) return dir;
+    const parent = path.dirname(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return startDir;
+}
+var __moduleFilename = fileURLToPath(import.meta.url);
+var PROJECT_ROOT = findProjectRoot(path.dirname(__moduleFilename));
+var EXTENSIONS_DIR = path.join(PROJECT_ROOT, "extensions");
+function tryLoadExtension(db, name, envVar, candidates, log2) {
+  for (const extPath of candidates) {
+    try {
+      db.loadExtension(extPath);
+      log2.info(`Loaded ${name} extension from ${extPath}`, {
+        code: "SQLITE_EXTENSION"
+      });
+      return;
+    } catch {
+    }
+  }
+  log2.warning(`${name} extension not available. Set ${envVar} env var.`, {
+    code: "SQLITE_EXTENSION"
+  });
+}
+function loadSpatialite(db, log2) {
+  const spatialitePaths = [
+    process.env["SPATIALITE_PATH"],
+    // Absolute paths to local extensions
+    path.join(
+      EXTENSIONS_DIR,
+      "mod_spatialite-5.1.0-win-amd64",
+      "mod_spatialite"
+    ),
+    path.join(
+      EXTENSIONS_DIR,
+      "mod_spatialite-5.1.0-win-amd64",
+      "mod_spatialite.dll"
+    ),
+    // System paths
+    "mod_spatialite",
+    "mod_spatialite.dll",
+    "/usr/lib/x86_64-linux-gnu/mod_spatialite.so",
+    "/usr/local/lib/mod_spatialite.so",
+    "/usr/local/lib/mod_spatialite.dylib"
+  ].filter((p) => Boolean(p));
+  const envSpatialitePath = process.env["SPATIALITE_PATH"];
+  if (envSpatialitePath && process.platform === "win32") {
+    const spatialiteExtDir = path.dirname(envSpatialitePath);
+    const currentPath = process.env["PATH"] ?? "";
+    if (!currentPath.includes(spatialiteExtDir)) {
+      process.env["PATH"] = spatialiteExtDir + ";" + currentPath;
+    }
+  }
+  tryLoadExtension(db, "SpatiaLite", "SPATIALITE_PATH", spatialitePaths, log2);
+}
+function loadCsvExtension(db, log2) {
+  const csvPaths = [
+    process.env["CSV_EXTENSION_PATH"],
+    // sqlite-xsv extension with absolute paths
+    path.join(EXTENSIONS_DIR, "xsv0.dll"),
+    path.join(EXTENSIONS_DIR, "xsv0"),
+    // System paths
+    "xsv0",
+    "xsv0.dll",
+    "csv",
+    "csv.dll",
+    "csv.so",
+    "/usr/local/lib/csv.so",
+    "/usr/local/lib/csv.dylib"
+  ].filter((p) => Boolean(p));
+  tryLoadExtension(db, "CSV", "CSV_EXTENSION_PATH", csvPaths, log2);
+}
+
+// src/adapters/sqlite-native/transaction-methods.ts
+function beginTransaction(db) {
+  db.exec("BEGIN TRANSACTION");
+}
+function commitTransaction(db) {
+  db.exec("COMMIT");
+}
+function rollbackTransaction(db) {
+  db.exec("ROLLBACK");
+}
+function savepoint(db, name) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new ValidationError(
+      "Invalid savepoint name. Must start with a letter/underscore and contain only alphanumeric chars.",
+      "INVALID_SAVEPOINT_NAME"
+    );
+  }
+  db.exec(`SAVEPOINT "${name}"`);
+}
+function releaseSavepoint(db, name) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new Error(
+      "Invalid savepoint name. Must start with a letter/underscore and contain only alphanumeric chars."
+    );
+  }
+  db.exec(`RELEASE SAVEPOINT "${name}"`);
+}
+function rollbackToSavepoint(db, name) {
+  if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name)) {
+    throw new Error(
+      "Invalid savepoint name. Must start with a letter/underscore and contain only alphanumeric chars."
+    );
+  }
+  db.exec(`ROLLBACK TO SAVEPOINT "${name}"`);
+}
+
+// src/adapters/sqlite-native/native-query-executor.ts
+function nativeExecuteRead(db, sql, params, log2) {
+  const start = Date.now();
+  try {
+    const stmt = db.prepare(sql);
+    const normalizedParams = normalizeSqliteParams(params);
+    const rows = normalizedParams ? stmt.all(...normalizedParams) : stmt.all();
+    return Promise.resolve({
+      rows,
+      columns: stmt.columns().map((c) => ({ name: c.name, type: c.type ?? "unknown" })),
+      executionTimeMs: Date.now() - start
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log2.error(`Query failed: ${message}`, {
+      code: ERROR_CODES.DB.QUERY_FAILED.full
+    });
+    throw new QueryError(
+      `Query execution failed: ${message}`,
+      "DB_QUERY_FAILED",
+      {
+        sql,
+        cause: error instanceof Error ? error : void 0
+      }
+    );
+  }
+}
+function nativeExecuteWrite(db, sql, params, log2) {
+  const start = Date.now();
+  try {
+    const stmt = db.prepare(sql);
+    const normalizedParams = normalizeSqliteParams(params);
+    const info = normalizedParams ? stmt.run(...normalizedParams) : stmt.run();
+    return Promise.resolve({
+      rows: [],
+      rowsAffected: info.changes,
+      executionTimeMs: Date.now() - start
+    });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    log2.error(`Write query failed: ${message}`, {
+      code: ERROR_CODES.DB.QUERY_FAILED.full
+    });
+    throw new QueryError(`Write query failed: ${message}`, "DB_WRITE_FAILED", {
+      sql,
+      cause: error instanceof Error ? error : void 0
+    });
+  }
+}
+
+// src/adapters/sqlite-native/native-sqlite-adapter.ts
+var log = logger.child("NATIVE_SQLITE");
+var NativeSqliteAdapter = class extends DatabaseAdapter {
+  type = "sqlite";
+  name = "Native SQLite Adapter (better-sqlite3)";
+  version = "1.0.0";
+  /**
+   * Check if this adapter uses native (better-sqlite3) backend.
+   * Returns true for native adapter.
+   */
+  isNativeBackend() {
+    return true;
+  }
+  /**
+   * Get the configured database file path.
+   * Returns the user-configured path, not internal WASM virtual filesystem paths.
+   */
+  getConfiguredPath() {
+    const config = this.config;
+    return config?.filePath ?? config?.connectionString ?? ":memory:";
+  }
+  db = null;
+  schemaManager = null;
+  cachedToolDefinitions = null;
+  /**
+   * Connect to a SQLite database using better-sqlite3
+   */
+  connect(config) {
+    if (config.type !== "sqlite") {
+      throw new ConfigurationError(
+        `Invalid database type: expected 'sqlite', got '${config.type}'`,
+        "DB_TYPE_MISMATCH"
+      );
+    }
+    const sqliteConfig = config;
+    this.config = sqliteConfig;
+    try {
+      const filePath = sqliteConfig.filePath ?? sqliteConfig.connectionString ?? ":memory:";
+      this.db = new Database(filePath, {
+        readonly: false,
+        fileMustExist: false
+      });
+      log.info(`Connected to SQLite database (native): ${filePath}`, {
+        code: "SQLITE_CONNECT"
+      });
+      this.applyOptions(sqliteConfig.options);
+      const db = this.db;
+      autoEnableWal(
+        { runPragma: (pragma) => db.pragma(pragma) },
+        filePath,
+        sqliteConfig.options,
+        log
+      );
+      detectAndSetJsonbSupport(() => {
+        const versionResult = db.prepare("SELECT sqlite_version()").get();
+        return versionResult?.["sqlite_version()"] ?? "0.0.0";
+      }, log);
+      this.schemaManager = new SchemaManager(this);
+      this.connected = true;
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      log.error(`Failed to connect to native SQLite: ${message}`, {
+        code: ERROR_CODES.DB.CONNECT_FAILED.full
+      });
+      throw new ConnectionError(
+        `Native SQLite connection failed: ${message}`,
+        "DB_CONNECT_FAILED",
+        {
+          cause: error instanceof Error ? error : void 0
+        }
+      );
+    }
+    return Promise.resolve();
+  }
+  /**
+   * Apply SQLite PRAGMA options and load extensions
+   */
+  applyOptions(options) {
+    if (!this.db || !options) return;
+    const db = this.db;
+    applyCommonPragmas({ runPragma: (pragma) => db.pragma(pragma) }, options);
+    if (options.spatialite) {
+      loadSpatialite(db, log);
+    }
+    if (options.csv) {
+      loadCsvExtension(db, log);
+    }
+  }
+  /**
+   * Disconnect from the database
+   */
+  disconnect() {
+    if (this.db) {
+      this.db.close();
+      this.db = null;
+      this.connected = false;
+      log.info("Disconnected from native SQLite database", {
+        code: "SQLITE_DISCONNECT"
+      });
+    }
+    return Promise.resolve();
+  }
+  /**
+   * Get health status
+   */
+  getHealth() {
+    if (!this.db || !this.connected) {
+      return Promise.resolve({
+        connected: false,
+        latencyMs: 0
+      });
+    }
+    const start = Date.now();
+    try {
+      this.db.prepare("SELECT 1").get();
+      return Promise.resolve({
+        connected: true,
+        latencyMs: Date.now() - start,
+        details: {
+          backend: "better-sqlite3",
+          fts5: this.hasFts5(),
+          spatialite: isSpatialiteLoaded(this)
+        }
+      });
+    } catch {
+      return Promise.resolve({
+        connected: false,
+        latencyMs: Date.now() - start
+      });
+    }
+  }
+  /**
+   * Check if FTS5 is available via compile options.
+   * Uses PRAGMA compile_options instead of creating a virtual table probe,
+   * which can fail when SpatiaLite extensions are loaded.
+   */
+  hasFts5() {
+    if (!this.db) return false;
+    try {
+      const rows = this.db.prepare("PRAGMA compile_options").all();
+      return rows.some((r) => r.compile_options === "ENABLE_FTS5");
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Execute a read query
+   */
+  executeReadQuery(sql, params) {
+    this.ensureConnected();
+    return nativeExecuteRead(this.ensureDb(), sql, params, log);
+  }
+  /**
+   * Execute a write query
+   */
+  executeWriteQuery(sql, params) {
+    this.ensureConnected();
+    const result = nativeExecuteWrite(this.ensureDb(), sql, params, log);
+    if (isDDL(sql)) {
+      this.clearSchemaCache();
+    }
+    return result;
+  }
+  /**
+   * Execute any query
+   */
+  executeQuery(sql, params) {
+    const trimmed = sql.trim().toUpperCase();
+    if (trimmed.startsWith("SELECT") || trimmed.startsWith("PRAGMA") || trimmed.startsWith("EXPLAIN")) {
+      return this.executeReadQuery(sql, params);
+    }
+    return this.executeWriteQuery(sql, params);
+  }
+  /**
+   * Get schema information (cached via SchemaManager)
+   */
+  async getSchema() {
+    this.ensureConnected();
+    if (this.schemaManager) {
+      return this.schemaManager.getSchema();
+    }
+    const tables = await this.listTables();
+    return { tables, indexes: [] };
+  }
+  /**
+   * List all tables (cached via SchemaManager)
+   */
+  async listTables() {
+    this.ensureConnected();
+    if (this.schemaManager) {
+      return this.schemaManager.listTables();
+    }
+    const result = await this.executeReadQuery(
+      `SELECT name, type FROM sqlite_master
+       WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%'
+       ORDER BY name`
+    );
+    const tables = [];
+    for (const row of result.rows ?? []) {
+      const name = row["name"];
+      const type = row["type"];
+      const tableInfo = await this.describeTable(name);
+      tables.push({ ...tableInfo, type });
+    }
+    return tables;
+  }
+  /**
+   * Describe a table (cached via SchemaManager)
+   */
+  async describeTable(tableName) {
+    this.ensureConnected();
+    if (this.schemaManager) {
+      return this.schemaManager.describeTable(tableName);
+    }
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableName)) {
+      throw new DbMcpError(
+        "Invalid table name",
+        "SQLITE_INVALID_TABLE",
+        "validation" /* VALIDATION */
+      );
+    }
+    const result = await this.executeReadQuery(
+      `PRAGMA table_info("${tableName}")`
+    );
+    if (!result.rows || result.rows.length === 0) {
+      throw new DbMcpError(
+        `Table '${tableName}' does not exist`,
+        "SQLITE_TABLE_NOT_FOUND",
+        "resource" /* RESOURCE */
+      );
+    }
+    return {
+      name: tableName,
+      type: "table",
+      columns: (result.rows ?? []).map((c) => ({
+        name: c["name"],
+        type: c["type"],
+        nullable: c["notnull"] === 0,
+        primaryKey: c["pk"] > 0
+      }))
+    };
+  }
+  /**
+   * List schemas (SQLite only has one)
+   */
+  listSchemas() {
+    return Promise.resolve(["main"]);
+  }
+  /**
+   * Get all indexes in the database (cached via SchemaManager)
+   * Required by sqlite_indexes resource
+   */
+  async getAllIndexes() {
+    this.ensureConnected();
+    if (this.schemaManager) {
+      return this.schemaManager.getAllIndexes();
+    }
+    const db = this.ensureDb();
+    const indexes = db.prepare(
+      `SELECT name, tbl_name, sql
+         FROM sqlite_master
+         WHERE type = 'index' AND sql IS NOT NULL
+         ORDER BY tbl_name, name`
+    ).all();
+    return indexes.map((idx) => {
+      const indexInfo = db.prepare(`PRAGMA index_info("${idx.name}")`).all();
+      return {
+        name: idx.name,
+        tableName: idx.tbl_name,
+        columns: indexInfo.map((col) => col.name),
+        unique: idx.sql?.toUpperCase().includes("UNIQUE") ?? false
+      };
+    });
+  }
+  /**
+   * Clear the schema metadata cache.
+   * Called automatically after DDL operations.
+   */
+  clearSchemaCache() {
+    if (this.schemaManager) {
+      this.schemaManager.clearCache();
+    }
+  }
+  /**
+   * Get capabilities
+   */
+  getCapabilities() {
+    return {
+      json: true,
+      fullTextSearch: true,
+      vector: true,
+      geospatial: true,
+      transactions: true,
+      preparedStatements: true,
+      connectionPooling: false,
+      // better-sqlite3 is single-connection
+      windowFunctions: true,
+      spatialite: true
+    };
+  }
+  /**
+   * Get supported tool groups
+   */
+  getSupportedToolGroups() {
+    return [
+      "core",
+      "json",
+      "text",
+      "stats",
+      "vector",
+      "admin",
+      "geo",
+      "introspection",
+      "migration"
+    ];
+  }
+  /**
+   * Get all tool definitions (cached — immutable per adapter instance)
+   */
+  getToolDefinitions() {
+    if (this.cachedToolDefinitions) return this.cachedToolDefinitions;
+    this.cachedToolDefinitions = getNativeToolDefinitions(this);
+    return this.cachedToolDefinitions;
+  }
+  /**
+   * Get resource definitions
+   */
+  getResourceDefinitions() {
+    return getResourceDefinitions(this);
+  }
+  /**
+   * Get prompt definitions
+   */
+  getPromptDefinitions() {
+    return getPromptDefinitions(this);
+  }
+  /**
+   * Ensure database is connected
+   */
+  ensureConnected() {
+    super.ensureConnected();
+    if (!this.db) {
+      throw new ConnectionError(
+        "Not connected to database",
+        "DB_NOT_CONNECTED"
+      );
+    }
+  }
+  /**
+   * Ensure database is connected and return database instance
+   */
+  ensureDb() {
+    this.ensureConnected();
+    const db = this.db;
+    if (!db) {
+      throw new ConnectionError(
+        "Not connected to database",
+        "DB_NOT_CONNECTED"
+      );
+    }
+    return db;
+  }
+  /**
+   * Get the raw database instance (for tools)
+   */
+  getDatabase() {
+    return this.ensureDb();
+  }
+  /**
+   * Execute raw SQL and return results (for tools)
+   */
+  rawQuery(sql, params) {
+    return this.executeQuery(sql, params);
+  }
+  /**
+   * Begin a transaction
+   */
+  beginTransaction() {
+    beginTransaction(this.ensureDb());
+  }
+  /**
+   * Commit a transaction
+   */
+  commitTransaction() {
+    commitTransaction(this.ensureDb());
+  }
+  /**
+   * Rollback a transaction
+   */
+  rollbackTransaction() {
+    rollbackTransaction(this.ensureDb());
+  }
+  /**
+   * Create a savepoint
+   */
+  savepoint(name) {
+    savepoint(this.ensureDb(), name);
+  }
+  /**
+   * Release a savepoint
+   */
+  releaseSavepoint(name) {
+    releaseSavepoint(this.ensureDb(), name);
+  }
+  /**
+   * Rollback to a savepoint
+   */
+  rollbackToSavepoint(name) {
+    rollbackToSavepoint(this.ensureDb(), name);
+  }
+};
+function createNativeSqliteAdapter() {
+  return new NativeSqliteAdapter();
+}
+
+export { NativeSqliteAdapter, createNativeSqliteAdapter, getSpatialiteTools, getTransactionTools, getWindowTools };