database-devtools 0.1.0 → 0.1.2

package/dist/chunk-7UY2LDRW.js

@@ -0,0 +1,2739 @@
+import { createDevToolsClient, formatRefreshErrorMessage, handleDeviceSnapshotUpload } from './chunk-UNVCJMJK.js';
+import { generateDeviceId } from './chunk-AZECU6D7.js';
+import { DevToolsRole, REFRESH_TIMEOUT_MS, buildDevToolsWsUrl, DEFAULT_DEVTOOLS_PORT } from './chunk-CPVVIH5G.js';
+import { resolveAdapter } from './chunk-BLOSGEQV.js';
+import { detectExpoSqliteInspectable } from './chunk-I65IM47D.js';
+import { __require } from './chunk-DGUM43GV.js';
+import { StyleSheet, View, useWindowDimensions, PanResponder, Pressable, Modal, Text, ActivityIndicator, ScrollView, TextInput, Platform, FlatList } from 'react-native';
+import { createContext, useState, useMemo, useRef, useCallback, useEffect, useContext } from 'react';
+import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
+import MaterialCommunityIcons from '@expo/vector-icons/MaterialCommunityIcons';
+
+// src/types/adapter.ts
+function isWritableDatabaseAdapter(adapter) {
+  if (!adapter?.capabilities.transactionalWrites) {
+    return false;
+  }
+  const candidate = adapter;
+  return typeof candidate.beginTransaction === "function" && typeof candidate.commitTransaction === "function" && typeof candidate.rollbackTransaction === "function" && typeof candidate.executeWrite === "function";
+}
+var isEditableDatabaseAdapter = isWritableDatabaseAdapter;
+
+// src/client/handleWriteOperations.ts
+async function handleBeginTransaction(adapter, message, report) {
+  if (!isWritableDatabaseAdapter(adapter)) {
+    report({
+      transactionId: message.transactionId,
+      action: "begin",
+      ok: false,
+      message: "Database adapter does not support writes"
+    });
+    return;
+  }
+  try {
+    await adapter.beginTransaction();
+    report({
+      transactionId: message.transactionId,
+      action: "begin",
+      ok: true
+    });
+  } catch (error) {
+    report({
+      transactionId: message.transactionId,
+      action: "begin",
+      ok: false,
+      message: error instanceof Error ? error.message : "Failed to begin transaction"
+    });
+  }
+}
+async function handleCommitTransaction(adapter, message, report) {
+  if (!isWritableDatabaseAdapter(adapter)) {
+    report({
+      transactionId: message.transactionId,
+      action: "commit",
+      ok: false,
+      message: "Database adapter does not support writes"
+    });
+    return;
+  }
+  try {
+    await adapter.commitTransaction();
+    report({
+      transactionId: message.transactionId,
+      action: "commit",
+      ok: true
+    });
+  } catch (error) {
+    report({
+      transactionId: message.transactionId,
+      action: "commit",
+      ok: false,
+      message: error instanceof Error ? error.message : "Failed to commit transaction"
+    });
+  }
+}
+async function handleRollbackTransaction(adapter, message, report) {
+  if (!isWritableDatabaseAdapter(adapter)) {
+    report({
+      transactionId: message.transactionId,
+      action: "rollback",
+      ok: false,
+      message: "Database adapter does not support writes"
+    });
+    return;
+  }
+  try {
+    await adapter.rollbackTransaction();
+    report({
+      transactionId: message.transactionId,
+      action: "rollback",
+      ok: true
+    });
+  } catch (error) {
+    report({
+      transactionId: message.transactionId,
+      action: "rollback",
+      ok: false,
+      message: error instanceof Error ? error.message : "Failed to roll back transaction"
+    });
+  }
+}
+async function handleExecuteWrite(adapter, message, report) {
+  if (!isWritableDatabaseAdapter(adapter)) {
+    report({
+      writeId: message.writeId,
+      transactionId: message.transactionId,
+      ok: false,
+      message: "Database adapter does not support writes"
+    });
+    return;
+  }
+  try {
+    const result = await adapter.executeWrite(message.operation);
+    report({
+      writeId: message.writeId,
+      transactionId: message.transactionId,
+      ok: true,
+      rowsAffected: result.rowsAffected
+    });
+  } catch (error) {
+    report({
+      writeId: message.writeId,
+      transactionId: message.transactionId,
+      ok: false,
+      message: error instanceof Error ? error.message : "Write operation failed"
+    });
+  }
+}
+
+// src/utils/sqlSafety.ts
+var BLOCKED_KEYWORDS = /\b(INSERT|UPDATE|DELETE|DROP|ALTER|CREATE|REPLACE|ATTACH|DETACH|REINDEX|VACUUM|TRUNCATE)\b/i;
+function validateReadOnlySql(sql) {
+  const trimmed = sql.trim();
+  if (!trimmed) {
+    throw new Error("SQL query is empty");
+  }
+  if (BLOCKED_KEYWORDS.test(trimmed)) {
+    throw new Error(
+      "DevTools is read-only; only SELECT, PRAGMA, EXPLAIN, and WITH queries are allowed"
+    );
+  }
+  const statements = trimmed.split(";").map((statement) => statement.trim()).filter(Boolean);
+  for (const statement of statements) {
+    const leading = statement.replace(/^\s*(--[^\n]*\n|\/\*[\s\S]*?\*\/\s*)*/g, "").trim();
+    const keyword = leading.split(/\s+/)[0]?.toUpperCase();
+    if (!keyword) {
+      continue;
+    }
+    if (keyword !== "SELECT" && keyword !== "PRAGMA" && keyword !== "EXPLAIN" && keyword !== "WITH") {
+      throw new Error(`DevTools is read-only; "${keyword}" statements are not allowed`);
+    }
+  }
+}
+
+// src/mobile/sqliteTableQuery.ts
+function quoteIdentifier(name) {
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function buildSearchClause(columns, search) {
+  const term = search?.trim();
+  if (!term || columns.length === 0) {
+    return { clause: "", params: [] };
+  }
+  const pattern = `%${term}%`;
+  const conditions = columns.map(
+    (column) => `CAST(${quoteIdentifier(column.name)} AS TEXT) LIKE ?`
+  );
+  return {
+    clause: ` WHERE (${conditions.join(" OR ")})`,
+    params: columns.map(() => pattern)
+  };
+}
+function resolveSortColumn(columns, sortColumn) {
+  if (!sortColumn) {
+    return null;
+  }
+  return columns.some((column) => column.name === sortColumn) ? sortColumn : null;
+}
+
+// src/mobile/createExpoSqliteInspector.ts
+function normalizeCell(cell) {
+  if (cell === null || cell === void 0) {
+    return null;
+  }
+  if (typeof cell === "number" || typeof cell === "string") {
+    return cell;
+  }
+  if (typeof cell === "boolean") {
+    return cell ? 1 : 0;
+  }
+  if (cell instanceof Uint8Array) {
+    return `[BLOB ${cell.byteLength} bytes]`;
+  }
+  return String(cell);
+}
+function objectRowsToMatrix(rows) {
+  if (rows.length === 0) {
+    return { columns: [], matrix: [] };
+  }
+  const columns = Object.keys(rows[0]);
+  return {
+    columns,
+    matrix: rows.map((row) => columns.map((column) => normalizeCell(row[column])))
+  };
+}
+function createExpoSqliteInspector(database) {
+  let operationQueue = Promise.resolve();
+  const enqueue = async (operation) => {
+    const next = operationQueue.then(operation);
+    operationQueue = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  };
+  const listTablesInternal = async () => {
+    const masterRows = await database.getAllAsync(
+      `SELECT name FROM sqlite_master
+       WHERE type = 'table' AND name NOT LIKE 'sqlite_%'
+       ORDER BY name`
+    );
+    const tables = [];
+    for (const row of masterRows) {
+      const countRow = await database.getFirstAsync(
+        `SELECT COUNT(*) AS count FROM ${quoteIdentifier(row.name)}`
+      );
+      tables.push({
+        name: row.name,
+        rowCount: Number(countRow?.count ?? 0)
+      });
+    }
+    return tables;
+  };
+  const getTableColumnsInternal = async (table) => {
+    const rows = await database.getAllAsync(
+      `PRAGMA table_info(${quoteIdentifier(table)})`
+    );
+    return rows.map((row) => ({
+      name: row.name,
+      type: row.type || "ANY",
+      notNull: row.notnull === 1,
+      pk: row.pk === 1,
+      defaultValue: row.dflt_value === null || row.dflt_value === void 0 ? null : String(row.dflt_value)
+    }));
+  };
+  return {
+    listTables: () => enqueue(listTablesInternal),
+    getSchema: () => enqueue(async () => {
+      const tables = await listTablesInternal();
+      return Promise.all(
+        tables.map(async (table) => ({
+          name: table.name,
+          columns: await getTableColumnsInternal(table.name)
+        }))
+      );
+    }),
+    getTableColumns: (table) => enqueue(() => getTableColumnsInternal(table)),
+    getDatabaseInfo: () => enqueue(async () => {
+      const tables = await listTablesInternal();
+      const versionRow = await database.getFirstAsync(
+        "SELECT sqlite_version() AS version"
+      );
+      const pageRow = await database.getFirstAsync(
+        "SELECT page_size, page_count FROM pragma_page_size(), pragma_page_count()"
+      );
+      const pageSize = Number(pageRow?.page_size ?? 0);
+      const pageCount = Number(pageRow?.page_count ?? 0);
+      return {
+        name: database.databasePath.split("/").pop() ?? database.databasePath,
+        path: database.databasePath,
+        tableCount: tables.length,
+        sqliteVersion: versionRow?.version ?? "unknown",
+        pageSize,
+        pageCount,
+        estimatedSizeBytes: pageSize * pageCount
+      };
+    }),
+    fetchTablePage: (request) => enqueue(async () => {
+      const columns = await getTableColumnsInternal(request.table);
+      const { clause, params: searchParams } = buildSearchClause(columns, request.search);
+      const quotedTable = quoteIdentifier(request.table);
+      const countRow = await database.getFirstAsync(
+        `SELECT COUNT(*) AS count FROM ${quotedTable}${clause}`,
+        searchParams
+      );
+      const totalCount = Number(countRow?.count ?? 0);
+      const pageSize = Math.max(1, request.pageSize);
+      const page = Math.max(1, request.page);
+      const offset = (page - 1) * pageSize;
+      const sortColumn = resolveSortColumn(columns, request.sortColumn);
+      const orderClause = sortColumn ? ` ORDER BY ${quoteIdentifier(sortColumn)} ${request.sortDir === "desc" ? "DESC" : "ASC"}` : "";
+      const rows = await database.getAllAsync(
+        `SELECT * FROM ${quotedTable}${clause}${orderClause} LIMIT ? OFFSET ?`,
+        [...searchParams, pageSize, offset]
+      );
+      const { columns: resultColumns, matrix } = objectRowsToMatrix(rows);
+      return {
+        columns: resultColumns,
+        rows: matrix,
+        totalCount,
+        page,
+        pageSize
+      };
+    }),
+    executeQuery: (sql) => enqueue(async () => {
+      validateReadOnlySql(sql);
+      const started = Date.now();
+      const rows = await database.getAllAsync(sql);
+      const { columns, matrix } = objectRowsToMatrix(rows);
+      return {
+        columns,
+        rows: matrix,
+        rowCount: matrix.length,
+        durationMs: Date.now() - started
+      };
+    })
+  };
+}
+
+// src/utils/isDevToolsEnabled.ts
+function isDevToolsEnabled(enabled) {
+  if (enabled === false) {
+    return false;
+  }
+  if (enabled === true) {
+    return true;
+  }
+  return typeof __DEV__ !== "undefined" && __DEV__;
+}
+var DevToolsContext = createContext(null);
+function useDevTools() {
+  const context = useContext(DevToolsContext);
+  if (!context) {
+    throw new Error("useDevTools must be used within DevToolsProvider");
+  }
+  return context;
+}
+
+// src/utils/resolveDevToolsHost.ts
+var ANDROID_LOOPBACK_HOSTS = /* @__PURE__ */ new Set(["localhost", "127.0.0.1", "::1"]);
+var ANDROID_EMULATOR_HOST = "10.0.2.2";
+function isAndroidLoopbackHost(host) {
+  return ANDROID_LOOPBACK_HOSTS.has(host.toLowerCase());
+}
+function readMetroDevHostFromConstants(constants) {
+  const hostUri = constants?.expoConfig?.hostUri ?? constants?.expoGoConfig?.debuggerHost ?? constants?.manifest2?.extra?.expoGo?.debuggerHost ?? constants?.manifest?.debuggerHost;
+  if (typeof hostUri !== "string" || hostUri.length === 0) {
+    return void 0;
+  }
+  return hostUri.split(":")[0];
+}
+function resolveDevToolsHostFromInputs(platformOs, metroHost) {
+  if (platformOs === "android") {
+    if (metroHost && !isAndroidLoopbackHost(metroHost)) {
+      return metroHost;
+    }
+    return ANDROID_EMULATOR_HOST;
+  }
+  if (metroHost) {
+    return metroHost;
+  }
+  return "localhost";
+}
+function getConnectionHintForPlatform(platformOs, serverUrl) {
+  try {
+    const parsed = new URL(serverUrl);
+    const host = parsed.hostname.toLowerCase();
+    if (platformOs === "android" && isAndroidLoopbackHost(host)) {
+      return `On Android, "${host}" refers to the device itself. Use ${ANDROID_EMULATOR_HOST} (emulator) or your PC's LAN IP (physical device).`;
+    }
+    if (parsed.protocol !== "ws:" && parsed.protocol !== "wss:") {
+      return "Server URL must start with ws:// or wss://";
+    }
+  } catch {
+    return "Invalid WebSocket URL.";
+  }
+  return null;
+}
+function getPlatformOs() {
+  try {
+    const { Platform: Platform2 } = __require("react-native");
+    return Platform2.OS;
+  } catch {
+    return "web";
+  }
+}
+function readMetroDevHostRuntime() {
+  try {
+    const mod = __require("expo-constants");
+    return readMetroDevHostFromConstants(mod.default);
+  } catch {
+    return void 0;
+  }
+}
+function resolveDevToolsHost() {
+  return resolveDevToolsHostFromInputs(getPlatformOs(), readMetroDevHostRuntime());
+}
+function getConnectionHint(serverUrl) {
+  return getConnectionHintForPlatform(getPlatformOs(), serverUrl);
+}
+function getExpoConstants() {
+  try {
+    const mod = __require("expo-constants");
+    return mod.default;
+  } catch {
+    return void 0;
+  }
+}
+function resolveDeviceMetadata() {
+  const constants = getExpoConstants();
+  const config = constants?.expoConfig;
+  const metadata = {
+    platform: Platform.OS,
+    appName: config?.name ?? "React Native App"
+  };
+  if (config?.version) {
+    metadata.appVersion = config.version;
+  }
+  const bundleId = config?.ios?.bundleIdentifier ?? config?.android?.package;
+  if (bundleId) {
+    metadata.bundleId = bundleId;
+  }
+  return metadata;
+}
+
+// src/utils/resolveServerUrl.ts
+function normalizeServerUrl(url) {
+  const trimmed = url.trim();
+  if (trimmed.startsWith("ws://") || trimmed.startsWith("wss://")) {
+    return trimmed;
+  }
+  return buildDevToolsWsUrl(trimmed.replace(/^https?:\/\//, ""), DEFAULT_DEVTOOLS_PORT);
+}
+function resolveServerUrl(serverUrl) {
+  if (serverUrl) {
+    return normalizeServerUrl(serverUrl);
+  }
+  const envUrl = typeof process !== "undefined" ? process.env.EXPO_PUBLIC_DATABASE_DEVTOOLS_URL : void 0;
+  if (envUrl) {
+    return normalizeServerUrl(envUrl);
+  }
+  return buildDevToolsWsUrl(resolveDevToolsHost(), DEFAULT_DEVTOOLS_PORT);
+}
+
+// src/utils/persistDeviceId.ts
+var PERSISTED_DEVICE_ID_STORAGE_KEY = "@database-devtools/device-id";
+var memoryDeviceId = null;
+function createAsyncStorageDeviceIdStore() {
+  try {
+    const AsyncStorage = __require("@react-native-async-storage/async-storage").default;
+    return AsyncStorage;
+  } catch {
+    return null;
+  }
+}
+async function loadOrCreateDeviceId(storage = createAsyncStorageDeviceIdStore()) {
+  if (storage) {
+    const stored = await storage.getItem(PERSISTED_DEVICE_ID_STORAGE_KEY);
+    if (stored) {
+      return stored;
+    }
+    const created = generateDeviceId();
+    await storage.setItem(PERSISTED_DEVICE_ID_STORAGE_KEY, created);
+    return created;
+  }
+  if (!memoryDeviceId) {
+    memoryDeviceId = generateDeviceId();
+  }
+  return memoryDeviceId;
+}
+function DevToolsProvider({
+  children,
+  database,
+  type,
+  adapter: explicitAdapter,
+  serverUrl: initialServerUrl,
+  onConnectionStateChange
+}) {
+  const [connectionState, setConnectionState] = useState("connecting");
+  const [connectionError, setConnectionError] = useState(null);
+  const [serverUrl, setServerUrl] = useState(() => resolveServerUrl(initialServerUrl));
+  const [deviceId, setDeviceId] = useState();
+  const [deviceIdReady, setDeviceIdReady] = useState(false);
+  const [settingsVisible, setSettingsVisible] = useState(false);
+  const [launcherVisible, setLauncherVisible] = useState(false);
+  const [explorerVisible, setExplorerVisible] = useState(false);
+  const [mobileInspector, setMobileInspector] = useState(null);
+  const [resolvedAdapter, setResolvedAdapter] = useState(explicitAdapter);
+  const [adapterError, setAdapterError] = useState(null);
+  const [exportState, setExportState] = useState("idle");
+  const [exportError, setExportError] = useState(null);
+  const metadata = useMemo(() => resolveDeviceMetadata(), []);
+  const clientRef = useRef(null);
+  const onConnectionStateChangeRef = useRef(onConnectionStateChange);
+  const databaseRef = useRef(resolvedAdapter);
+  const rollbackOpenTransactionRef = useRef(null);
+  const exportWaitersRef = useRef(null);
+  const exportTimeoutRef = useRef(null);
+  const exportSuccessTimeoutRef = useRef(null);
+  const clearExportWaiters = useCallback(() => {
+    if (exportTimeoutRef.current) {
+      clearTimeout(exportTimeoutRef.current);
+      exportTimeoutRef.current = null;
+    }
+    exportWaitersRef.current = null;
+  }, []);
+  const resetExportSuccessLater = useCallback(() => {
+    if (exportSuccessTimeoutRef.current) {
+      clearTimeout(exportSuccessTimeoutRef.current);
+    }
+    exportSuccessTimeoutRef.current = setTimeout(() => {
+      setExportState((current) => current === "success" ? "idle" : current);
+      exportSuccessTimeoutRef.current = null;
+    }, 3e3);
+  }, []);
+  const finishExportSuccess = useCallback(() => {
+    clearExportWaiters();
+    setExportState("success");
+    setExportError(null);
+    resetExportSuccessLater();
+  }, [clearExportWaiters, resetExportSuccessLater]);
+  const finishExportFailure = useCallback(
+    (message) => {
+      clearExportWaiters();
+      setExportState("error");
+      setExportError(message);
+    },
+    [clearExportWaiters]
+  );
+  useEffect(() => {
+    onConnectionStateChangeRef.current = onConnectionStateChange;
+  }, [onConnectionStateChange]);
+  useEffect(() => {
+    let cancelled = false;
+    async function resolveDatabaseAdapter() {
+      if (explicitAdapter) {
+        setResolvedAdapter(explicitAdapter);
+        setAdapterError(null);
+        return;
+      }
+      if (!database) {
+        setResolvedAdapter(void 0);
+        setAdapterError(null);
+        return;
+      }
+      try {
+        const nextAdapter = await resolveAdapter(database, { type });
+        if (!cancelled) {
+          setResolvedAdapter(nextAdapter);
+          setAdapterError(null);
+        }
+      } catch (error) {
+        if (!cancelled) {
+          setResolvedAdapter(void 0);
+          setAdapterError(error instanceof Error ? error.message : "Failed to resolve database adapter");
+        }
+      }
+    }
+    void resolveDatabaseAdapter();
+    return () => {
+      cancelled = true;
+    };
+  }, [database, type, explicitAdapter]);
+  useEffect(() => {
+    if (detectExpoSqliteInspectable(database)) {
+      setMobileInspector(createExpoSqliteInspector(database));
+      return;
+    }
+    setMobileInspector(null);
+  }, [database]);
+  useEffect(() => {
+    databaseRef.current = resolvedAdapter;
+  }, [resolvedAdapter]);
+  useEffect(() => {
+    rollbackOpenTransactionRef.current = async () => {
+      const adapter = databaseRef.current;
+      if (!isWritableDatabaseAdapter(adapter)) {
+        return;
+      }
+      try {
+        await adapter.rollbackTransaction();
+      } catch {
+      }
+    };
+  }, [resolvedAdapter]);
+  useEffect(() => {
+    let cancelled = false;
+    void loadOrCreateDeviceId().then((persistedId) => {
+      if (!cancelled) {
+        setDeviceId(persistedId);
+        setDeviceIdReady(true);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  useEffect(() => {
+    if (!deviceIdReady || !deviceId) {
+      return;
+    }
+    const client = createDevToolsClient({
+      serverUrl,
+      role: DevToolsRole.MOBILE,
+      deviceId,
+      metadata,
+      onConnect: () => {
+        setConnectionError(null);
+      },
+      onConnectionStateChange: (state) => {
+        setConnectionState(state);
+        onConnectionStateChangeRef.current?.(state);
+      },
+      onError: (error) => {
+        setConnectionError(error.message);
+      },
+      onSnapshotUploadRequested: async (message) => {
+        try {
+          await handleDeviceSnapshotUpload(databaseRef.current, message, {
+            hubServerUrl: serverUrl,
+            deviceId: clientRef.current?.getDeviceId()
+          });
+          if (exportWaitersRef.current) {
+            exportWaitersRef.current.resolve();
+            clearExportWaiters();
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : "Database export or upload failed";
+          if (exportWaitersRef.current) {
+            exportWaitersRef.current.reject(new Error(errorMessage));
+            clearExportWaiters();
+            return;
+          }
+          console.error("[database-devtools] Snapshot export or upload failed:", errorMessage);
+        }
+      },
+      onExportSnapshotError: (message) => {
+        const errorMessage = formatRefreshErrorMessage(message.code, message.message);
+        if (exportWaitersRef.current) {
+          exportWaitersRef.current.reject(new Error(errorMessage));
+          clearExportWaiters();
+        }
+      },
+      onBeginTransaction: async (message) => {
+        const client2 = clientRef.current;
+        if (!client2) {
+          return;
+        }
+        await handleBeginTransaction(databaseRef.current, message, (ack) => {
+          client2.sendTransactionAck(ack);
+        });
+      },
+      onCommitTransaction: async (message) => {
+        const client2 = clientRef.current;
+        if (!client2) {
+          return;
+        }
+        await handleCommitTransaction(databaseRef.current, message, (ack) => {
+          client2.sendTransactionAck(ack);
+        });
+      },
+      onRollbackTransaction: async (message) => {
+        const client2 = clientRef.current;
+        if (!client2) {
+          return;
+        }
+        await handleRollbackTransaction(databaseRef.current, message, (ack) => {
+          client2.sendTransactionAck(ack);
+        });
+      },
+      onExecuteWrite: async (message) => {
+        const client2 = clientRef.current;
+        if (!client2) {
+          return;
+        }
+        await handleExecuteWrite(databaseRef.current, message, (ack) => {
+          client2.sendWriteAck(ack);
+        });
+      }
+    });
+    clientRef.current = client;
+    setDeviceId(client.getDeviceId());
+    client.connect();
+    return () => {
+      void rollbackOpenTransactionRef.current?.();
+      client.disconnect();
+      clientRef.current = null;
+      clearExportWaiters();
+      if (exportSuccessTimeoutRef.current) {
+        clearTimeout(exportSuccessTimeoutRef.current);
+        exportSuccessTimeoutRef.current = null;
+      }
+    };
+  }, [serverUrl, metadata, clearExportWaiters, deviceIdReady, deviceId]);
+  const openLauncher = useCallback(() => {
+    setLauncherVisible(true);
+  }, []);
+  const closeLauncher = useCallback(() => {
+    setLauncherVisible(false);
+  }, []);
+  const openExplorer = useCallback(() => {
+    setLauncherVisible(false);
+    setExplorerVisible(true);
+  }, []);
+  const closeExplorer = useCallback(() => {
+    setExplorerVisible(false);
+  }, []);
+  const openSettings = useCallback(() => {
+    setLauncherVisible(false);
+    setSettingsVisible(true);
+  }, []);
+  const closeSettings = useCallback(() => {
+    setSettingsVisible(false);
+  }, []);
+  const reconnect = useCallback((url) => {
+    setConnectionError(null);
+    setServerUrl(normalizeServerUrl(url));
+  }, []);
+  const exportDatabase = useCallback(async () => {
+    if (exportState === "exporting") {
+      return;
+    }
+    if (connectionState !== "connected") {
+      finishExportFailure("Connect to the DevTools hub first");
+      return;
+    }
+    if (!resolvedAdapter) {
+      finishExportFailure(adapterError ?? "No database adapter connected");
+      return;
+    }
+    const client = clientRef.current;
+    if (!client) {
+      finishExportFailure("DevTools client is not ready");
+      return;
+    }
+    setExportState("exporting");
+    setExportError(null);
+    try {
+      await new Promise((resolve, reject) => {
+        exportWaitersRef.current = { resolve, reject };
+        exportTimeoutRef.current = setTimeout(() => {
+          exportWaitersRef.current?.reject(new Error("Export timed out"));
+          clearExportWaiters();
+        }, REFRESH_TIMEOUT_MS);
+        client.requestExportSnapshot();
+      });
+      finishExportSuccess();
+    } catch (error) {
+      const message = error instanceof Error ? error.message : "Export failed";
+      finishExportFailure(message);
+    }
+  }, [
+    adapterError,
+    connectionState,
+    exportState,
+    finishExportFailure,
+    resolvedAdapter
+  ]);
+  const connectionHint = useMemo(() => getConnectionHint(serverUrl), [serverUrl]);
+  const value = useMemo(
+    () => ({
+      connectionState,
+      connectionError,
+      connectionHint,
+      deviceId,
+      serverUrl,
+      metadata,
+      database: resolvedAdapter,
+      adapterError,
+      mobileInspector,
+      launcherVisible,
+      openLauncher,
+      closeLauncher,
+      explorerVisible,
+      openExplorer,
+      closeExplorer,
+      settingsVisible,
+      openSettings,
+      closeSettings,
+      reconnect,
+      exportState,
+      exportError,
+      exportDatabase
+    }),
+    [
+      connectionState,
+      connectionError,
+      connectionHint,
+      deviceId,
+      serverUrl,
+      metadata,
+      resolvedAdapter,
+      adapterError,
+      mobileInspector,
+      launcherVisible,
+      openLauncher,
+      closeLauncher,
+      explorerVisible,
+      openExplorer,
+      closeExplorer,
+      settingsVisible,
+      openSettings,
+      closeSettings,
+      reconnect,
+      exportState,
+      exportError,
+      exportDatabase
+    ]
+  );
+  return /* @__PURE__ */ jsx(DevToolsContext.Provider, { value, children });
+}
+function getStatusConfig(state) {
+  switch (state) {
+    case "connected":
+      return { label: "Connected", color: "#166534", backgroundColor: "#dcfce7" };
+    case "reconnecting":
+      return { label: "Reconnecting", color: "#92400e", backgroundColor: "#fef3c7" };
+    case "connecting":
+      return { label: "Connecting", color: "#92400e", backgroundColor: "#fef3c7" };
+    case "disconnected":
+      return { label: "Disconnected", color: "#991b1b", backgroundColor: "#fee2e2" };
+  }
+}
+function getConnectionDotColor(state) {
+  switch (state) {
+    case "connected":
+      return "#22c55e";
+    case "reconnecting":
+    case "connecting":
+      return "#eab308";
+    case "disconnected":
+      return "#ef4444";
+  }
+}
+function ConnectionStatusBadge({ state }) {
+  const config = getStatusConfig(state);
+  return /* @__PURE__ */ jsxs(View, { style: [styles.badge, { backgroundColor: config.backgroundColor }], children: [
+    /* @__PURE__ */ jsx(View, { style: [styles.dot, { backgroundColor: getConnectionDotColor(state) }] }),
+    /* @__PURE__ */ jsx(Text, { style: [styles.label, { color: config.color }], children: config.label })
+  ] });
+}
+var styles = StyleSheet.create({
+  badge: {
+    flexDirection: "row",
+    alignItems: "center",
+    alignSelf: "flex-start",
+    paddingHorizontal: 10,
+    paddingVertical: 6,
+    borderRadius: 999,
+    gap: 6
+  },
+  dot: {
+    width: 8,
+    height: 8,
+    borderRadius: 4
+  },
+  label: {
+    fontSize: 13,
+    fontWeight: "600"
+  }
+});
+function DevToolsLauncherModal() {
+  const {
+    launcherVisible,
+    closeLauncher,
+    openExplorer,
+    openSettings,
+    connectionState,
+    mobileInspector,
+    exportState,
+    exportError,
+    exportDatabase,
+    database,
+    adapterError
+  } = useDevTools();
+  const isExporting = exportState === "exporting";
+  const exportDisabled = connectionState !== "connected" || !database || isExporting || Boolean(adapterError);
+  return /* @__PURE__ */ jsx(
+    Modal,
+    {
+      animationType: "slide",
+      onRequestClose: closeLauncher,
+      transparent: true,
+      visible: launcherVisible,
+      children: /* @__PURE__ */ jsx(View, { style: styles2.overlay, children: /* @__PURE__ */ jsxs(View, { style: styles2.sheet, children: [
+        /* @__PURE__ */ jsxs(View, { style: styles2.header, children: [
+          /* @__PURE__ */ jsx(Text, { style: styles2.title, children: "Database DevTools" }),
+          /* @__PURE__ */ jsx(Pressable, { accessibilityLabel: "Close launcher", onPress: closeLauncher, children: /* @__PURE__ */ jsx(Text, { style: styles2.closeButton, children: "Close" }) })
+        ] }),
+        /* @__PURE__ */ jsxs(View, { style: styles2.body, children: [
+          /* @__PURE__ */ jsx(ConnectionStatusBadge, { state: connectionState }),
+          /* @__PURE__ */ jsx(Text, { style: styles2.hint, children: "Browse and query the on-device database, or connect to the web inspector." }),
+          /* @__PURE__ */ jsx(
+            Pressable,
+            {
+              accessibilityLabel: "View database on device",
+              disabled: !mobileInspector,
+              onPress: openExplorer,
+              style: [styles2.primaryButton, !mobileInspector && styles2.primaryButtonDisabled],
+              children: /* @__PURE__ */ jsx(Text, { style: styles2.primaryLabel, children: "View Database" })
+            }
+          ),
+          !mobileInspector ? /* @__PURE__ */ jsx(Text, { style: styles2.warning, children: "On-device explorer requires an Expo SQLite database instance." }) : null,
+          /* @__PURE__ */ jsx(
+            Pressable,
+            {
+              accessibilityLabel: "Open DevTools settings",
+              onPress: openSettings,
+              style: styles2.secondaryButton,
+              children: /* @__PURE__ */ jsx(Text, { style: styles2.secondaryLabel, children: "DevTools Settings" })
+            }
+          ),
+          /* @__PURE__ */ jsx(
+            Pressable,
+            {
+              accessibilityLabel: "Export database to web inspector",
+              accessibilityState: { busy: isExporting, disabled: exportDisabled },
+              disabled: exportDisabled,
+              onPress: () => void exportDatabase(),
+              style: [styles2.ghostButton, exportDisabled && !isExporting && styles2.buttonDisabled],
+              children: /* @__PURE__ */ jsxs(View, { style: styles2.exportContent, children: [
+                isExporting ? /* @__PURE__ */ jsx(ActivityIndicator, { color: "#0f172a", size: "small" }) : null,
+                /* @__PURE__ */ jsx(Text, { style: styles2.ghostLabel, children: isExporting ? "Exporting\u2026" : "Export to Web Inspector" })
+              ] })
+            }
+          ),
+          connectionState !== "connected" ? /* @__PURE__ */ jsx(Text, { style: styles2.hint, children: "Connect to the hub in settings before exporting." }) : null,
+          exportState === "success" ? /* @__PURE__ */ jsx(Text, { style: styles2.success, children: "Sent to web inspector" }) : null,
+          exportError ? /* @__PURE__ */ jsx(Text, { style: styles2.error, children: exportError }) : null,
+          adapterError ? /* @__PURE__ */ jsx(Text, { style: styles2.error, children: adapterError }) : null
+        ] })
+      ] }) })
+    }
+  );
+}
+var styles2 = StyleSheet.create({
+  overlay: {
+    flex: 1,
+    backgroundColor: "rgba(0, 0, 0, 0.45)",
+    justifyContent: "flex-end"
+  },
+  sheet: {
+    backgroundColor: "#ffffff",
+    borderTopLeftRadius: 16,
+    borderTopRightRadius: 16,
+    overflow: "hidden"
+  },
+  header: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    paddingHorizontal: 20,
+    paddingVertical: 16,
+    borderBottomWidth: StyleSheet.hairlineWidth,
+    borderBottomColor: "#e2e8f0"
+  },
+  title: {
+    fontSize: 18,
+    fontWeight: "700",
+    color: "#0f172a"
+  },
+  closeButton: {
+    fontSize: 16,
+    color: "#2563eb",
+    fontWeight: "600"
+  },
+  body: {
+    padding: 20,
+    gap: 12
+  },
+  hint: {
+    fontSize: 13,
+    color: "#64748b",
+    lineHeight: 20
+  },
+  warning: {
+    fontSize: 12,
+    color: "#b45309",
+    marginTop: -4
+  },
+  primaryButton: {
+    backgroundColor: "#2563eb",
+    borderRadius: 8,
+    paddingVertical: 14,
+    alignItems: "center"
+  },
+  primaryButtonDisabled: {
+    opacity: 0.5
+  },
+  primaryLabel: {
+    color: "#f8fafc",
+    fontSize: 16,
+    fontWeight: "700"
+  },
+  secondaryButton: {
+    backgroundColor: "#1e293b",
+    borderRadius: 8,
+    paddingVertical: 12,
+    alignItems: "center"
+  },
+  secondaryLabel: {
+    color: "#f8fafc",
+    fontSize: 15,
+    fontWeight: "600"
+  },
+  ghostButton: {
+    borderWidth: 1,
+    borderColor: "#cbd5e1",
+    borderRadius: 8,
+    paddingVertical: 12,
+    alignItems: "center"
+  },
+  buttonDisabled: {
+    opacity: 0.5
+  },
+  ghostLabel: {
+    color: "#0f172a",
+    fontSize: 15,
+    fontWeight: "600"
+  },
+  exportContent: {
+    flexDirection: "row",
+    alignItems: "center",
+    gap: 8
+  },
+  success: {
+    fontSize: 13,
+    color: "#15803d"
+  },
+  error: {
+    fontSize: 13,
+    color: "#dc2626"
+  }
+});
+function DevToolsSettingsModal() {
+  const {
+    settingsVisible,
+    closeSettings,
+    connectionState,
+    connectionError,
+    connectionHint,
+    deviceId,
+    serverUrl,
+    metadata,
+    database,
+    adapterError,
+    reconnect,
+    exportState,
+    exportError,
+    exportDatabase
+  } = useDevTools();
+  const [draftUrl, setDraftUrl] = useState(serverUrl);
+  useEffect(() => {
+    if (settingsVisible) {
+      setDraftUrl(serverUrl);
+    }
+  }, [settingsVisible, serverUrl]);
+  const handleReconnect = () => {
+    const trimmed = draftUrl.trim();
+    if (trimmed) {
+      reconnect(trimmed);
+    }
+  };
+  const handleExportDatabase = () => {
+    void exportDatabase();
+  };
+  const isExporting = exportState === "exporting";
+  const exportDisabled = connectionState !== "connected" || !database || isExporting;
+  return /* @__PURE__ */ jsx(
+    Modal,
+    {
+      animationType: "slide",
+      onRequestClose: closeSettings,
+      transparent: true,
+      visible: settingsVisible,
+      children: /* @__PURE__ */ jsx(View, { style: styles3.overlay, children: /* @__PURE__ */ jsxs(View, { style: styles3.sheet, children: [
+        /* @__PURE__ */ jsxs(View, { style: styles3.header, children: [
+          /* @__PURE__ */ jsx(Text, { style: styles3.title, children: "Database DevTools" }),
+          /* @__PURE__ */ jsx(Pressable, { accessibilityLabel: "Close settings", onPress: closeSettings, children: /* @__PURE__ */ jsx(Text, { style: styles3.closeButton, children: "Close" }) })
+        ] }),
+        /* @__PURE__ */ jsxs(
+          ScrollView,
+          {
+            contentContainerStyle: styles3.content,
+            style: styles3.scrollBody,
+            children: [
+              /* @__PURE__ */ jsxs(Section, { title: "Connection", children: [
+                /* @__PURE__ */ jsx(ConnectionStatusBadge, { state: connectionState }),
+                /* @__PURE__ */ jsx(InfoRow, { label: "Server URL", value: serverUrl, mono: true }),
+                connectionError ? /* @__PURE__ */ jsx(Text, { style: styles3.errorText, children: connectionError }) : null,
+                connectionHint ? /* @__PURE__ */ jsx(Text, { style: styles3.hintText, children: connectionHint }) : null,
+                connectionState === "reconnecting" ? /* @__PURE__ */ jsx(Text, { style: styles3.hintText, children: "Ensure the inspector hub is running (npx database-devtools) and the URL reaches your development machine \u2014 not the phone itself." }) : null
+              ] }),
+              /* @__PURE__ */ jsxs(Section, { title: "Device", children: [
+                /* @__PURE__ */ jsx(InfoRow, { label: "Device ID", value: deviceId ?? "\u2014", mono: true }),
+                /* @__PURE__ */ jsx(InfoRow, { label: "Platform", value: metadata.platform ?? "\u2014" }),
+                /* @__PURE__ */ jsx(InfoRow, { label: "App", value: metadata.appName ?? "\u2014" }),
+                metadata.appVersion ? /* @__PURE__ */ jsx(InfoRow, { label: "Version", value: metadata.appVersion }) : null,
+                metadata.bundleId ? /* @__PURE__ */ jsx(InfoRow, { label: "Bundle ID", value: metadata.bundleId, mono: true }) : null
+              ] }),
+              /* @__PURE__ */ jsxs(Section, { title: "Server", children: [
+                /* @__PURE__ */ jsx(Text, { style: styles3.fieldLabel, children: "WebSocket URL" }),
+                /* @__PURE__ */ jsx(
+                  TextInput,
+                  {
+                    autoCapitalize: "none",
+                    autoCorrect: false,
+                    onChangeText: setDraftUrl,
+                    placeholder: "ws://10.0.2.2:3847/ws",
+                    style: styles3.input,
+                    value: draftUrl
+                  }
+                ),
+                /* @__PURE__ */ jsx(Pressable, { onPress: handleReconnect, style: styles3.reconnectButton, children: /* @__PURE__ */ jsx(Text, { style: styles3.reconnectLabel, children: "Reconnect" }) })
+              ] }),
+              /* @__PURE__ */ jsx(Section, { title: "Database", children: database ? /* @__PURE__ */ jsxs(Fragment, { children: [
+                /* @__PURE__ */ jsx(InfoRow, { label: "Kind", value: database.kind }),
+                /* @__PURE__ */ jsx(InfoRow, { label: "Name", value: database.name }),
+                /* @__PURE__ */ jsx(InfoRow, { label: "ID", value: database.id, mono: true })
+              ] }) : /* @__PURE__ */ jsx(Text, { style: styles3.placeholder, children: adapterError ? "Adapter not connected" : "No adapter connected" }) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxs(View, { style: styles3.exportFooter, children: [
+          adapterError ? /* @__PURE__ */ jsx(Text, { style: styles3.errorText, children: adapterError }) : null,
+          database ? /* @__PURE__ */ jsxs(Fragment, { children: [
+            /* @__PURE__ */ jsx(
+              Pressable,
+              {
+                accessibilityLabel: "Export database to web inspector",
+                accessibilityState: { busy: isExporting, disabled: exportDisabled },
+                disabled: exportDisabled,
+                onPress: handleExportDatabase,
+                style: [
+                  styles3.exportButton,
+                  exportDisabled && !isExporting && styles3.exportButtonDisabled
+                ],
+                children: /* @__PURE__ */ jsxs(View, { style: styles3.exportButtonContent, children: [
+                  isExporting ? /* @__PURE__ */ jsx(ActivityIndicator, { color: "#f8fafc", size: "small" }) : null,
+                  /* @__PURE__ */ jsx(Text, { style: styles3.exportLabel, children: isExporting ? "Exporting\u2026" : "Export Database" })
+                ] })
+              }
+            ),
+            connectionState !== "connected" ? /* @__PURE__ */ jsx(Text, { style: styles3.hintText, children: "Connect to the hub before exporting." }) : null,
+            exportState === "success" ? /* @__PURE__ */ jsx(Text, { style: styles3.successText, children: "Sent to web inspector" }) : null,
+            exportError ? /* @__PURE__ */ jsx(Text, { style: styles3.errorText, children: exportError }) : null
+          ] }) : /* @__PURE__ */ jsx(Text, { style: styles3.placeholder, children: adapterError ? "Adapter not connected" : "No adapter connected" })
+        ] })
+      ] }) })
+    }
+  );
+}
+function Section({ title, children }) {
+  return /* @__PURE__ */ jsxs(View, { style: styles3.section, children: [
+    /* @__PURE__ */ jsx(Text, { style: styles3.sectionTitle, children: title }),
+    children
+  ] });
+}
+function InfoRow({
+  label,
+  value,
+  mono = false
+}) {
+  return /* @__PURE__ */ jsxs(View, { style: styles3.infoRow, children: [
+    /* @__PURE__ */ jsx(Text, { style: styles3.infoLabel, children: label }),
+    /* @__PURE__ */ jsx(Text, { style: [styles3.infoValue, mono && styles3.mono], selectable: true, children: value })
+  ] });
+}
+var styles3 = StyleSheet.create({
+  overlay: {
+    flex: 1,
+    backgroundColor: "rgba(0, 0, 0, 0.45)",
+    justifyContent: "flex-end"
+  },
+  sheet: {
+    backgroundColor: "#ffffff",
+    borderTopLeftRadius: 16,
+    borderTopRightRadius: 16,
+    maxHeight: "85%",
+    overflow: "hidden"
+  },
+  scrollBody: {
+    flexGrow: 0,
+    flexShrink: 1
+  },
+  header: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    paddingHorizontal: 20,
+    paddingVertical: 16,
+    borderBottomWidth: StyleSheet.hairlineWidth,
+    borderBottomColor: "#e2e8f0"
+  },
+  title: {
+    fontSize: 18,
+    fontWeight: "700",
+    color: "#0f172a"
+  },
+  closeButton: {
+    fontSize: 16,
+    color: "#2563eb",
+    fontWeight: "600"
+  },
+  exportFooter: {
+    paddingHorizontal: 20,
+    paddingTop: 12,
+    paddingBottom: 20,
+    gap: 8,
+    borderTopWidth: StyleSheet.hairlineWidth,
+    borderTopColor: "#e2e8f0",
+    backgroundColor: "#ffffff"
+  },
+  content: {
+    padding: 20,
+    gap: 20
+  },
+  section: {
+    gap: 10
+  },
+  sectionTitle: {
+    fontSize: 13,
+    fontWeight: "600",
+    color: "#64748b",
+    textTransform: "uppercase",
+    letterSpacing: 0.5
+  },
+  infoRow: {
+    gap: 2
+  },
+  infoLabel: {
+    fontSize: 12,
+    color: "#94a3b8"
+  },
+  infoValue: {
+    fontSize: 14,
+    color: "#0f172a"
+  },
+  mono: {
+    fontFamily: "monospace",
+    fontSize: 12
+  },
+  fieldLabel: {
+    fontSize: 12,
+    color: "#64748b",
+    marginBottom: 4
+  },
+  input: {
+    borderWidth: 1,
+    borderColor: "#cbd5e1",
+    borderRadius: 8,
+    paddingHorizontal: 12,
+    paddingVertical: 10,
+    fontSize: 14,
+    color: "#0f172a",
+    fontFamily: "monospace"
+  },
+  reconnectButton: {
+    marginTop: 8,
+    backgroundColor: "#1e293b",
+    borderRadius: 8,
+    paddingVertical: 12,
+    alignItems: "center"
+  },
+  reconnectLabel: {
+    color: "#f8fafc",
+    fontSize: 15,
+    fontWeight: "600"
+  },
+  exportButton: {
+    backgroundColor: "#2563eb",
+    borderRadius: 8,
+    paddingVertical: 12,
+    paddingHorizontal: 16,
+    alignItems: "center",
+    justifyContent: "center",
+    minHeight: 44
+  },
+  exportButtonContent: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "center",
+    gap: 8
+  },
+  exportButtonDisabled: {
+    opacity: 0.5
+  },
+  exportLabel: {
+    color: "#f8fafc",
+    fontSize: 15,
+    fontWeight: "600"
+  },
+  successText: {
+    fontSize: 13,
+    color: "#15803d"
+  },
+  placeholder: {
+    fontSize: 14,
+    color: "#94a3b8",
+    fontStyle: "italic"
+  },
+  errorText: {
+    fontSize: 13,
+    color: "#dc2626",
+    marginBottom: 8
+  },
+  hintText: {
+    fontSize: 12,
+    color: "#b45309",
+    lineHeight: 18
+  }
+});
+
+// src/utils/floatingButtonPosition.ts
+var FLOATING_BUTTON_SIZE = 48;
+var FLOATING_BUTTON_MARGIN = 16;
+var FLOATING_BUTTON_BOTTOM = 24;
+var FLOATING_BUTTON_TAP_THRESHOLD = 8;
+function getCornerPosition(corner, layout, bottomInset = FLOATING_BUTTON_BOTTOM) {
+  const { windowWidth, windowHeight, buttonSize, margin } = layout;
+  const y = windowHeight - bottomInset - buttonSize;
+  return {
+    x: corner === "bottom-right" ? windowWidth - margin - buttonSize : margin,
+    y
+  };
+}
+function clampFloatingPosition(position, layout) {
+  const { windowWidth, windowHeight, buttonSize, margin } = layout;
+  return {
+    x: Math.min(Math.max(margin, position.x), windowWidth - margin - buttonSize),
+    y: Math.min(Math.max(margin, position.y), windowHeight - margin - buttonSize)
+  };
+}
+function snapFloatingPositionToEdges(position, layout) {
+  const { windowWidth, windowHeight, buttonSize, margin } = layout;
+  const clamped = clampFloatingPosition(position, layout);
+  const centerX = clamped.x + buttonSize / 2;
+  const centerY = clamped.y + buttonSize / 2;
+  let x = centerX < windowWidth / 2 ? margin : windowWidth - margin - buttonSize;
+  let y = clamped.y;
+  if (centerY < windowHeight * 0.2) {
+    y = margin;
+  } else if (centerY > windowHeight * 0.8) {
+    y = windowHeight - margin - buttonSize;
+  }
+  return { x, y };
+}
+function isFloatingButtonTap(totalMovement) {
+  return totalMovement < FLOATING_BUTTON_TAP_THRESHOLD;
+}
+var DEFAULT_ICON_SIZE = 22;
+var DEFAULT_ICON_COLOR = "#f8fafc";
+function FloatingDevToolsButton({
+  position = "bottom-right",
+  iconStyle,
+  draggable = true,
+  snapToEdges = true,
+  floatingPosition,
+  onFloatingPositionChange
+}) {
+  const { connectionState, openLauncher } = useDevTools();
+  const { width: windowWidth, height: windowHeight } = useWindowDimensions();
+  const [internalPosition, setInternalPosition] = useState(null);
+  const [dragPosition, setDragPosition] = useState(null);
+  const dragOrigin = useRef({ x: 0, y: 0 });
+  const hasInitialized = useRef(false);
+  const onFloatingPositionChangeRef = useRef(onFloatingPositionChange);
+  useEffect(() => {
+    onFloatingPositionChangeRef.current = onFloatingPositionChange;
+  }, [onFloatingPositionChange]);
+  const layout = useMemo(
+    () => ({
+      windowWidth,
+      windowHeight,
+      buttonSize: FLOATING_BUTTON_SIZE,
+      margin: FLOATING_BUTTON_MARGIN
+    }),
+    [windowWidth, windowHeight]
+  );
+  const committedPosition = floatingPosition ?? internalPosition;
+  const renderedPosition = dragPosition ?? committedPosition;
+  const commitPosition = useCallback(
+    (next) => {
+      const clamped = clampFloatingPosition(next, layout);
+      if (!floatingPosition) {
+        setInternalPosition(clamped);
+      }
+      onFloatingPositionChangeRef.current?.(clamped);
+      return clamped;
+    },
+    [floatingPosition, layout]
+  );
+  useEffect(() => {
+    if (windowWidth <= 0 || windowHeight <= 0) {
+      return;
+    }
+    if (floatingPosition) {
+      hasInitialized.current = true;
+      return;
+    }
+    if (!hasInitialized.current) {
+      setInternalPosition(getCornerPosition(position, layout));
+      hasInitialized.current = true;
+    }
+  }, [floatingPosition, layout, position, windowHeight, windowWidth]);
+  useEffect(() => {
+    if (!committedPosition || windowWidth <= 0 || windowHeight <= 0) {
+      return;
+    }
+    const clamped = clampFloatingPosition(committedPosition, layout);
+    if (clamped.x !== committedPosition.x || clamped.y !== committedPosition.y) {
+      commitPosition(clamped);
+    }
+  }, [commitPosition, committedPosition, layout, windowHeight, windowWidth]);
+  const panResponder = useMemo(
+    () => PanResponder.create({
+      onStartShouldSetPanResponder: () => draggable,
+      onMoveShouldSetPanResponder: (_, gesture) => draggable && (Math.abs(gesture.dx) > 2 || Math.abs(gesture.dy) > 2),
+      onPanResponderGrant: () => {
+        if (!committedPosition) {
+          return;
+        }
+        dragOrigin.current = committedPosition;
+      },
+      onPanResponderMove: (_, gesture) => {
+        setDragPosition(
+          clampFloatingPosition(
+            {
+              x: dragOrigin.current.x + gesture.dx,
+              y: dragOrigin.current.y + gesture.dy
+            },
+            layout
+          )
+        );
+      },
+      onPanResponderRelease: (_, gesture) => {
+        setDragPosition(null);
+        const movement = Math.hypot(gesture.dx, gesture.dy);
+        if (isFloatingButtonTap(movement)) {
+          openLauncher();
+          return;
+        }
+        const raw = {
+          x: dragOrigin.current.x + gesture.dx,
+          y: dragOrigin.current.y + gesture.dy
+        };
+        const next = snapToEdges ? snapFloatingPositionToEdges(raw, layout) : clampFloatingPosition(raw, layout);
+        commitPosition(next);
+      },
+      onPanResponderTerminate: () => {
+        setDragPosition(null);
+      }
+    }),
+    [commitPosition, committedPosition, draggable, layout, openLauncher, snapToEdges]
+  );
+  if (!renderedPosition) {
+    return null;
+  }
+  const buttonContent = /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(
+      MaterialCommunityIcons,
+      {
+        color: DEFAULT_ICON_COLOR,
+        name: "database",
+        size: DEFAULT_ICON_SIZE,
+        style: iconStyle
+      }
+    ),
+    /* @__PURE__ */ jsx(
+      View,
+      {
+        style: [styles4.statusDot, { backgroundColor: getConnectionDotColor(connectionState) }]
+      }
+    )
+  ] });
+  if (!draggable) {
+    const positionStyle = position === "bottom-left" ? styles4.bottomLeft : styles4.bottomRight;
+    return /* @__PURE__ */ jsx(View, { style: [styles4.fixedContainer, positionStyle], pointerEvents: "box-none", children: /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        accessibilityLabel: "Open Database DevTools",
+        accessibilityRole: "button",
+        onPress: openLauncher,
+        style: ({ pressed }) => [styles4.button, pressed && styles4.buttonPressed],
+        children: buttonContent
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsx(
+    View,
+    {
+      pointerEvents: "box-none",
+      style: [
+        styles4.draggableContainer,
+        {
+          transform: [
+            { translateX: renderedPosition.x },
+            { translateY: renderedPosition.y }
+          ]
+        }
+      ],
+      ...panResponder.panHandlers,
+      children: /* @__PURE__ */ jsx(
+        View,
+        {
+          accessibilityHint: "Drag to move. Tap to open DevTools launcher.",
+          accessibilityLabel: "Open Database DevTools",
+          accessibilityRole: "button",
+          style: [styles4.button, dragPosition && styles4.buttonDragging],
+          children: buttonContent
+        }
+      )
+    }
+  );
+}
+var styles4 = StyleSheet.create({
+  fixedContainer: {
+    position: "absolute",
+    bottom: 24,
+    zIndex: 9999
+  },
+  bottomRight: {
+    right: 16
+  },
+  bottomLeft: {
+    left: 16
+  },
+  draggableContainer: {
+    position: "absolute",
+    top: 0,
+    left: 0,
+    zIndex: 9999
+  },
+  button: {
+    width: FLOATING_BUTTON_SIZE,
+    height: FLOATING_BUTTON_SIZE,
+    borderRadius: FLOATING_BUTTON_SIZE / 2,
+    backgroundColor: "#1e293b",
+    alignItems: "center",
+    justifyContent: "center",
+    shadowColor: "#000",
+    shadowOffset: { width: 0, height: 2 },
+    shadowOpacity: 0.25,
+    shadowRadius: 4,
+    elevation: 6
+  },
+  buttonPressed: {
+    opacity: 0.85
+  },
+  buttonDragging: {
+    opacity: 0.92,
+    transform: [{ scale: 1.04 }]
+  },
+  statusDot: {
+    position: "absolute",
+    top: 2,
+    right: 2,
+    width: 10,
+    height: 10,
+    borderRadius: 5,
+    borderWidth: 2,
+    borderColor: "#1e293b"
+  }
+});
+var explorerColors = {
+  background: "#ffffff",
+  surface: "#f8fafc",
+  border: "#e2e8f0",
+  text: "#0f172a",
+  muted: "#64748b",
+  subtle: "#94a3b8",
+  accent: "#2563eb",
+  accentSoft: "#dbeafe",
+  error: "#dc2626"};
+var explorerStyles = StyleSheet.create({
+  fullScreen: {
+    flex: 1,
+    backgroundColor: explorerColors.background
+  },
+  header: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    paddingHorizontal: 16,
+    paddingVertical: 14,
+    borderBottomWidth: StyleSheet.hairlineWidth,
+    borderBottomColor: explorerColors.border,
+    backgroundColor: explorerColors.background
+  },
+  headerTitle: {
+    fontSize: 17,
+    fontWeight: "700",
+    color: explorerColors.text
+  },
+  headerAction: {
+    fontSize: 16,
+    color: explorerColors.accent,
+    fontWeight: "600"
+  },
+  tabRow: {
+    flexDirection: "row",
+    borderBottomWidth: StyleSheet.hairlineWidth,
+    borderBottomColor: explorerColors.border,
+    backgroundColor: explorerColors.surface
+  },
+  tab: {
+    flex: 1,
+    paddingVertical: 12,
+    alignItems: "center",
+    borderBottomWidth: 2,
+    borderBottomColor: "transparent"
+  },
+  tabActive: {
+    borderBottomColor: explorerColors.accent
+  },
+  tabLabel: {
+    fontSize: 14,
+    color: explorerColors.muted,
+    fontWeight: "500"
+  },
+  tabLabelActive: {
+    color: explorerColors.accent,
+    fontWeight: "700"
+  },
+  content: {
+    flex: 1,
+    padding: 16
+  },
+  sectionTitle: {
+    fontSize: 12,
+    fontWeight: "600",
+    color: explorerColors.muted,
+    textTransform: "uppercase",
+    letterSpacing: 0.5,
+    marginBottom: 8
+  },
+  infoRow: {
+    marginBottom: 10
+  },
+  infoLabel: {
+    fontSize: 12,
+    color: explorerColors.subtle,
+    marginBottom: 2
+  },
+  infoValue: {
+    fontSize: 14,
+    color: explorerColors.text
+  },
+  mono: {
+    fontFamily: "monospace",
+    fontSize: 12
+  },
+  listItem: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    paddingVertical: 12,
+    paddingHorizontal: 12,
+    borderRadius: 8,
+    backgroundColor: explorerColors.surface,
+    marginBottom: 8,
+    borderWidth: 1,
+    borderColor: explorerColors.border
+  },
+  listItemTitle: {
+    fontSize: 15,
+    fontWeight: "600",
+    color: explorerColors.text,
+    fontFamily: "monospace"
+  },
+  listItemMeta: {
+    fontSize: 12,
+    color: explorerColors.muted
+  },
+  searchInput: {
+    borderWidth: 1,
+    borderColor: explorerColors.border,
+    borderRadius: 8,
+    paddingHorizontal: 12,
+    paddingVertical: 10,
+    fontSize: 14,
+    color: explorerColors.text,
+    backgroundColor: explorerColors.background,
+    marginBottom: 12
+  },
+  primaryButton: {
+    backgroundColor: explorerColors.accent,
+    borderRadius: 8,
+    paddingVertical: 12,
+    alignItems: "center",
+    justifyContent: "center",
+    minHeight: 44
+  },
+  primaryButtonDisabled: {
+    opacity: 0.5
+  },
+  primaryButtonLabel: {
+    color: "#f8fafc",
+    fontSize: 15,
+    fontWeight: "600"
+  },
+  secondaryButton: {
+    backgroundColor: "#1e293b",
+    borderRadius: 8,
+    paddingVertical: 12,
+    alignItems: "center",
+    justifyContent: "center",
+    minHeight: 44
+  },
+  secondaryButtonLabel: {
+    color: "#f8fafc",
+    fontSize: 15,
+    fontWeight: "600"
+  },
+  ghostButton: {
+    borderWidth: 1,
+    borderColor: explorerColors.border,
+    borderRadius: 8,
+    paddingVertical: 12,
+    alignItems: "center",
+    justifyContent: "center",
+    minHeight: 44,
+    backgroundColor: explorerColors.background
+  },
+  ghostButtonLabel: {
+    color: explorerColors.text,
+    fontSize: 15,
+    fontWeight: "600"
+  },
+  errorText: {
+    fontSize: 13,
+    color: explorerColors.error,
+    marginTop: 8
+  },
+  hintText: {
+    fontSize: 12,
+    color: explorerColors.muted,
+    marginTop: 8,
+    lineHeight: 18
+  },
+  placeholder: {
+    fontSize: 14,
+    color: explorerColors.subtle,
+    fontStyle: "italic",
+    textAlign: "center",
+    marginTop: 24
+  },
+  sqlInput: {
+    minHeight: 120,
+    borderWidth: 1,
+    borderColor: explorerColors.border,
+    borderRadius: 8,
+    paddingHorizontal: 12,
+    paddingVertical: 10,
+    fontSize: 13,
+    fontFamily: "monospace",
+    color: explorerColors.text,
+    textAlignVertical: "top",
+    backgroundColor: explorerColors.surface
+  },
+  sqlTabRoot: {
+    flex: 1,
+    minHeight: 0
+  },
+  sqlQueryPane: {
+    flexShrink: 0,
+    paddingHorizontal: 16,
+    paddingTop: 16,
+    paddingBottom: 12,
+    gap: 12,
+    borderBottomWidth: StyleSheet.hairlineWidth,
+    borderBottomColor: explorerColors.border,
+    backgroundColor: explorerColors.background
+  },
+  sqlInputCompact: {
+    minHeight: 96,
+    maxHeight: 120,
+    borderWidth: 1,
+    borderColor: explorerColors.border,
+    borderRadius: 8,
+    paddingHorizontal: 12,
+    paddingVertical: 10,
+    fontSize: 13,
+    fontFamily: "monospace",
+    color: explorerColors.text,
+    textAlignVertical: "top",
+    backgroundColor: explorerColors.surface
+  },
+  sqlResultsPane: {
+    flex: 1,
+    minHeight: 0,
+    paddingHorizontal: 16,
+    paddingTop: 8,
+    paddingBottom: 16
+  },
+  sqlResultsEmpty: {
+    flex: 1,
+    justifyContent: "center",
+    paddingHorizontal: 16
+  },
+  subTabRow: {
+    flexDirection: "row",
+    gap: 8,
+    marginBottom: 12
+  },
+  subTab: {
+    paddingHorizontal: 12,
+    paddingVertical: 6,
+    borderRadius: 999,
+    borderWidth: 1,
+    borderColor: explorerColors.border,
+    backgroundColor: explorerColors.background
+  },
+  subTabActive: {
+    borderColor: explorerColors.accent,
+    backgroundColor: explorerColors.accentSoft
+  },
+  subTabLabel: {
+    fontSize: 13,
+    color: explorerColors.muted
+  },
+  subTabLabelActive: {
+    color: explorerColors.accent,
+    fontWeight: "600"
+  },
+  paginationRow: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    paddingVertical: 12,
+    borderTopWidth: StyleSheet.hairlineWidth,
+    borderTopColor: explorerColors.border
+  },
+  paginationLabel: {
+    fontSize: 12,
+    color: explorerColors.muted
+  }
+});
+var tableStyles = StyleSheet.create({
+  viewRoot: {
+    flex: 1,
+    minHeight: 0
+  },
+  viewToolbar: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    gap: 8,
+    marginBottom: 8,
+    flexWrap: "wrap"
+  },
+  viewMeta: {
+    flex: 1,
+    fontSize: 12,
+    color: explorerColors.muted
+  },
+  viewToggle: {
+    flexDirection: "row",
+    borderWidth: 1,
+    borderColor: explorerColors.border,
+    borderRadius: 8,
+    overflow: "hidden"
+  },
+  viewToggleButton: {
+    paddingHorizontal: 10,
+    paddingVertical: 6,
+    backgroundColor: explorerColors.background
+  },
+  viewToggleButtonActive: {
+    backgroundColor: explorerColors.accentSoft
+  },
+  viewToggleLabel: {
+    fontSize: 12,
+    fontWeight: "600",
+    color: explorerColors.muted
+  },
+  viewToggleLabelActive: {
+    color: explorerColors.accent
+  },
+  footerHint: {
+    flexShrink: 0,
+    marginTop: 8,
+    fontSize: 11,
+    color: explorerColors.subtle,
+    textAlign: "center"
+  },
+  tableContainer: {
+    flex: 1,
+    minHeight: 0,
+    borderWidth: 1,
+    borderColor: explorerColors.border,
+    borderRadius: 8,
+    overflow: "hidden",
+    backgroundColor: explorerColors.background
+  },
+  horizontalScroll: {
+    flex: 1
+  },
+  scrollHint: {
+    paddingHorizontal: 10,
+    paddingVertical: 6,
+    fontSize: 11,
+    color: explorerColors.muted,
+    backgroundColor: explorerColors.surface,
+    borderBottomWidth: StyleSheet.hairlineWidth,
+    borderBottomColor: explorerColors.border
+  },
+  headerRow: {
+    flexDirection: "row",
+    backgroundColor: "#f1f5f9",
+    borderBottomWidth: 1,
+    borderBottomColor: explorerColors.border
+  },
+  headerCell: {
+    backgroundColor: "#f1f5f9"
+  },
+  headerText: {
+    fontSize: 12,
+    fontWeight: "700",
+    color: explorerColors.text,
+    fontFamily: "monospace"
+  },
+  bodyList: {
+    flex: 1
+  },
+  dataRow: {
+    flexDirection: "row",
+    backgroundColor: explorerColors.background
+  },
+  dataRowAlt: {
+    backgroundColor: explorerColors.surface
+  },
+  cell: {
+    paddingHorizontal: 10,
+    paddingVertical: 8,
+    borderRightWidth: 1,
+    borderBottomWidth: 1,
+    borderColor: explorerColors.border,
+    justifyContent: "center"
+  },
+  cellText: {
+    fontSize: 13,
+    color: explorerColors.text
+  },
+  cellTextMono: {
+    fontFamily: "monospace",
+    fontSize: 12
+  },
+  cellNull: {
+    color: explorerColors.subtle,
+    fontStyle: "italic"
+  },
+  copiedHint: {
+    marginTop: 2,
+    fontSize: 10,
+    color: explorerColors.accent,
+    fontWeight: "600"
+  },
+  cardList: {
+    paddingBottom: 8,
+    gap: 8
+  },
+  card: {
+    borderWidth: 1,
+    borderColor: explorerColors.border,
+    borderRadius: 8,
+    backgroundColor: explorerColors.surface,
+    padding: 12,
+    gap: 10
+  },
+  cardField: {
+    gap: 2
+  },
+  cardLabel: {
+    fontSize: 11,
+    fontWeight: "600",
+    color: explorerColors.muted,
+    textTransform: "uppercase",
+    letterSpacing: 0.4
+  },
+  cardValue: {
+    fontSize: 14,
+    color: explorerColors.text
+  },
+  cardValueMono: {
+    fontFamily: "monospace",
+    fontSize: 13
+  },
+  detailBody: {
+    flex: 1,
+    minHeight: 0,
+    paddingHorizontal: 16
+  },
+  detailDataPane: {
+    flex: 1,
+    minHeight: 0
+  }
+});
+function formatBytes(bytes) {
+  if (bytes < 1024) {
+    return `${bytes} B`;
+  }
+  if (bytes < 1024 * 1024) {
+    return `${(bytes / 1024).toFixed(1)} KB`;
+  }
+  return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+}
+function ExplorerOverviewTab({
+  info,
+  loading,
+  error,
+  onOpenTables,
+  onOpenSql
+}) {
+  if (loading) {
+    return /* @__PURE__ */ jsx(Text, { style: explorerStyles.placeholder, children: "Loading database info\u2026" });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx(Text, { style: explorerStyles.errorText, children: error });
+  }
+  if (!info) {
+    return /* @__PURE__ */ jsx(Text, { style: explorerStyles.placeholder, children: "No database information available." });
+  }
+  return /* @__PURE__ */ jsxs(ScrollView, { contentContainerStyle: explorerStyles.content, children: [
+    /* @__PURE__ */ jsx(Text, { style: explorerStyles.sectionTitle, children: "Database" }),
+    /* @__PURE__ */ jsx(Info, { label: "Name", value: info.name }),
+    /* @__PURE__ */ jsx(Info, { label: "Path", value: info.path, mono: true }),
+    /* @__PURE__ */ jsx(Info, { label: "SQLite version", value: info.sqliteVersion }),
+    /* @__PURE__ */ jsx(Info, { label: "Tables", value: String(info.tableCount) }),
+    /* @__PURE__ */ jsx(Info, { label: "Estimated size", value: formatBytes(info.estimatedSizeBytes) }),
+    /* @__PURE__ */ jsx(
+      Info,
+      {
+        label: "Pages",
+        value: `${info.pageCount.toLocaleString()} \xD7 ${info.pageSize} bytes`
+      }
+    ),
+    /* @__PURE__ */ jsx(View, { style: { height: 16 } }),
+    /* @__PURE__ */ jsx(Text, { style: explorerStyles.sectionTitle, children: "Quick actions" }),
+    /* @__PURE__ */ jsxs(View, { style: { gap: 8 }, children: [
+      /* @__PURE__ */ jsx(ActionButton, { label: "Browse tables", onPress: onOpenTables }),
+      /* @__PURE__ */ jsx(ActionButton, { label: "Run SQL query", onPress: onOpenSql })
+    ] })
+  ] });
+}
+function Info({ label, value, mono = false }) {
+  return /* @__PURE__ */ jsxs(View, { style: explorerStyles.infoRow, children: [
+    /* @__PURE__ */ jsx(Text, { style: explorerStyles.infoLabel, children: label }),
+    /* @__PURE__ */ jsx(Text, { style: [explorerStyles.infoValue, mono && explorerStyles.mono], selectable: true, children: value })
+  ] });
+}
+function ActionButton({ label, onPress }) {
+  return /* @__PURE__ */ jsx(Pressable, { onPress, style: explorerStyles.ghostButton, children: /* @__PURE__ */ jsx(Text, { style: explorerStyles.ghostButtonLabel, children: label }) });
+}
+
+// src/mobile/constants.ts
+var DEFAULT_MOBILE_SQL = "";
+var DEFAULT_PAGE_SIZE = 50;
+
+// src/mobile/computeColumnWidths.ts
+var CHAR_WIDTH = 7.5;
+var CELL_PADDING = 24;
+var MIN_COLUMN_WIDTH = 72;
+var MAX_COLUMN_WIDTH = 280;
+var SAMPLE_ROW_LIMIT = 20;
+function hintMinWidth(columnName) {
+  const lower = columnName.toLowerCase();
+  if (lower === "id" || lower.endsWith("_id")) {
+    return 80;
+  }
+  if (lower.includes("email")) {
+    return 168;
+  }
+  if (lower.includes("created_at") || lower.includes("updated_at") || lower.endsWith("_at")) {
+    return 188;
+  }
+  if (lower === "name" || lower.includes("title")) {
+    return 128;
+  }
+  if (lower === "status" || lower === "type") {
+    return 96;
+  }
+  return MIN_COLUMN_WIDTH;
+}
+function measureText(text) {
+  return Math.ceil(text.length * CHAR_WIDTH) + CELL_PADDING;
+}
+function formatCellValue(value) {
+  if (value === null) {
+    return "NULL";
+  }
+  return String(value);
+}
+function computeColumnWidths(columns, rows) {
+  const sampleRows = rows.slice(0, SAMPLE_ROW_LIMIT);
+  return columns.map((column, columnIndex) => {
+    let maxWidth = measureText(column);
+    for (const row of sampleRows) {
+      const cell = formatCellValue(row[columnIndex] ?? null);
+      maxWidth = Math.max(maxWidth, measureText(cell));
+    }
+    maxWidth = Math.max(maxWidth, hintMinWidth(column));
+    return Math.min(MAX_COLUMN_WIDTH, Math.max(MIN_COLUMN_WIDTH, maxWidth));
+  });
+}
+function totalTableWidth(columnWidths) {
+  return columnWidths.reduce((sum, width) => sum + width, 0);
+}
+function isMonospaceColumn(columnName) {
+  const lower = columnName.toLowerCase();
+  return lower === "id" || lower.endsWith("_id") || lower.includes("created_at") || lower.includes("updated_at") || lower.endsWith("_at") || lower.includes("date") || lower.includes("time");
+}
+
+// src/mobile/copyToClipboard.ts
+async function copyToClipboard(_text) {
+  return false;
+}
+function formatValue(value) {
+  return value === null ? "NULL" : String(value);
+}
+function MobileDataCardList({ columns, rows }) {
+  const [copiedKey, setCopiedKey] = useState(null);
+  const copyValue = async (value, key) => {
+    await copyToClipboard();
+    setCopiedKey(key);
+    setTimeout(() => setCopiedKey(null), 1500);
+  };
+  return /* @__PURE__ */ jsx(
+    FlatList,
+    {
+      data: rows,
+      keyExtractor: (_, index) => String(index),
+      contentContainerStyle: tableStyles.cardList,
+      style: tableStyles.bodyList,
+      renderItem: ({ item: row, index: rowIndex }) => /* @__PURE__ */ jsx(View, { style: tableStyles.card, children: columns.map((column, columnIndex) => {
+        const value = formatValue(row[columnIndex] ?? null);
+        const key = `${rowIndex}-${column}`;
+        const isNull = row[columnIndex] === null;
+        return /* @__PURE__ */ jsxs(
+          Pressable,
+          {
+            onPress: () => void copyValue(value, key),
+            style: tableStyles.cardField,
+            children: [
+              /* @__PURE__ */ jsx(Text, { style: tableStyles.cardLabel, children: column }),
+              /* @__PURE__ */ jsx(
+                Text,
+                {
+                  style: [
+                    tableStyles.cardValue,
+                    isMonospaceColumn(column) && tableStyles.cardValueMono,
+                    isNull && tableStyles.cellNull
+                  ],
+                  children: value
+                }
+              ),
+              copiedKey === key && /* @__PURE__ */ jsx(Text, { style: tableStyles.copiedHint, children: "Copied" })
+            ]
+          },
+          key
+        );
+      }) })
+    }
+  );
+}
+function formatValue2(value) {
+  return value === null ? "NULL" : String(value);
+}
+function MobileDataTable({ columns, rows, columnWidths: columnWidthsProp }) {
+  const { width: windowWidth } = useWindowDimensions();
+  const [copiedKey, setCopiedKey] = useState(null);
+  const columnWidths = useMemo(
+    () => columnWidthsProp ?? computeColumnWidths(columns, rows),
+    [columnWidthsProp, columns, rows]
+  );
+  const tableWidth = useMemo(() => totalTableWidth(columnWidths), [columnWidths]);
+  const showScrollHint = tableWidth > windowWidth - 32;
+  const copyCell = async (value, key) => {
+    await copyToClipboard();
+    setCopiedKey(key);
+    setTimeout(() => setCopiedKey(null), 1500);
+  };
+  if (columns.length === 0) {
+    return null;
+  }
+  const headerRow = /* @__PURE__ */ jsx(View, { style: tableStyles.headerRow, children: columns.map((column, index) => /* @__PURE__ */ jsx(
+    View,
+    {
+      style: [tableStyles.cell, tableStyles.headerCell, { width: columnWidths[index] }],
+      children: /* @__PURE__ */ jsx(Text, { style: tableStyles.headerText, children: column })
+    },
+    column
+  )) });
+  return /* @__PURE__ */ jsxs(View, { style: tableStyles.tableContainer, children: [
+    showScrollHint && /* @__PURE__ */ jsx(Text, { style: tableStyles.scrollHint, children: "Swipe horizontally for more columns" }),
+    /* @__PURE__ */ jsx(
+      ScrollView,
+      {
+        horizontal: true,
+        bounces: false,
+        nestedScrollEnabled: true,
+        showsHorizontalScrollIndicator: true,
+        style: tableStyles.horizontalScroll,
+        children: /* @__PURE__ */ jsxs(View, { style: { width: tableWidth, flex: 1 }, children: [
+          headerRow,
+          /* @__PURE__ */ jsx(
+            FlatList,
+            {
+              data: rows,
+              keyExtractor: (_, index) => String(index),
+              nestedScrollEnabled: true,
+              style: tableStyles.bodyList,
+              renderItem: ({ item: row, index: rowIndex }) => /* @__PURE__ */ jsx(View, { style: [tableStyles.dataRow, rowIndex % 2 === 1 && tableStyles.dataRowAlt], children: row.map((cell, cellIndex) => {
+                const column = columns[cellIndex];
+                const display = formatValue2(cell);
+                const key = `${rowIndex}-${cellIndex}`;
+                const isNull = cell === null;
+                return /* @__PURE__ */ jsxs(
+                  Pressable,
+                  {
+                    onPress: () => void copyCell(display, key),
+                    style: [tableStyles.cell, { width: columnWidths[cellIndex] }],
+                    children: [
+                      /* @__PURE__ */ jsx(
+                        Text,
+                        {
+                          numberOfLines: 2,
+                          selectable: true,
+                          style: [
+                            tableStyles.cellText,
+                            isMonospaceColumn(column) && tableStyles.cellTextMono,
+                            isNull && tableStyles.cellNull
+                          ],
+                          children: display
+                        }
+                      ),
+                      copiedKey === key && /* @__PURE__ */ jsx(Text, { style: tableStyles.copiedHint, children: "Copied" })
+                    ]
+                  },
+                  key
+                );
+              }) })
+            }
+          )
+        ] })
+      }
+    )
+  ] });
+}
+function MobileDataView({
+  columns,
+  rows,
+  metaSuffix,
+  defaultMode = "table",
+  dataKey
+}) {
+  const [mode, setMode] = useState(defaultMode);
+  const columnWidths = useMemo(() => computeColumnWidths(columns, rows), [columns, rows]);
+  const tableWidth = useMemo(() => totalTableWidth(columnWidths), [columnWidths]);
+  const columnsKey = columns.join("|");
+  useEffect(() => {
+    setMode(defaultMode);
+  }, [columnsKey, dataKey, defaultMode, rows.length]);
+  if (columns.length === 0) {
+    return /* @__PURE__ */ jsx(Text, { style: explorerStyles.placeholder, children: "No rows to display." });
+  }
+  const meta = `${rows.length} row${rows.length === 1 ? "" : "s"} \xB7 ${columns.length} column${columns.length === 1 ? "" : "s"}${metaSuffix ? ` \xB7 ${metaSuffix}` : ""}`;
+  return /* @__PURE__ */ jsxs(View, { style: tableStyles.viewRoot, children: [
+    /* @__PURE__ */ jsxs(View, { style: tableStyles.viewToolbar, children: [
+      /* @__PURE__ */ jsx(Text, { style: tableStyles.viewMeta, children: meta }),
+      /* @__PURE__ */ jsxs(View, { style: tableStyles.viewToggle, children: [
+        /* @__PURE__ */ jsx(
+          Pressable,
+          {
+            onPress: () => setMode("cards"),
+            style: [tableStyles.viewToggleButton, mode === "cards" && tableStyles.viewToggleButtonActive],
+            children: /* @__PURE__ */ jsx(
+              Text,
+              {
+                style: [tableStyles.viewToggleLabel, mode === "cards" && tableStyles.viewToggleLabelActive],
+                children: "Cards"
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsx(
+          Pressable,
+          {
+            onPress: () => setMode("table"),
+            style: [tableStyles.viewToggleButton, mode === "table" && tableStyles.viewToggleButtonActive],
+            children: /* @__PURE__ */ jsx(
+              Text,
+              {
+                style: [tableStyles.viewToggleLabel, mode === "table" && tableStyles.viewToggleLabelActive],
+                children: "Table"
+              }
+            )
+          }
+        )
+      ] })
+    ] }),
+    mode === "cards" ? /* @__PURE__ */ jsx(MobileDataCardList, { columns, rows }) : /* @__PURE__ */ jsx(MobileDataTable, { columnWidths, columns, rows }),
+    mode === "table" && tableWidth > 320 && /* @__PURE__ */ jsx(Text, { style: tableStyles.footerHint, children: "Tap a cell to copy its value" }),
+    mode === "cards" && /* @__PURE__ */ jsx(Text, { style: tableStyles.footerHint, children: "Tap a field to copy its value" })
+  ] });
+}
+function ExplorerSqlTab({ inspector }) {
+  const [sql, setSql] = useState(DEFAULT_MOBILE_SQL);
+  const [result, setResult] = useState(null);
+  const [error, setError] = useState(null);
+  const [running, setRunning] = useState(false);
+  const [panel, setPanel] = useState("results");
+  const [resultKey, setResultKey] = useState(0);
+  const runQuery = async () => {
+    setRunning(true);
+    setError(null);
+    try {
+      const queryResult = await inspector.executeQuery(sql);
+      setResult(queryResult);
+      setResultKey((current) => current + 1);
+      setPanel("results");
+    } catch (runError) {
+      const message = runError instanceof Error ? runError.message : "Query failed";
+      setError(message);
+      setResult(null);
+      setPanel("output");
+    } finally {
+      setRunning(false);
+    }
+  };
+  const renderResultsContent = () => {
+    if (panel === "output") {
+      if (error) {
+        return /* @__PURE__ */ jsx(Text, { style: explorerStyles.errorText, children: error });
+      }
+      if (result) {
+        return /* @__PURE__ */ jsxs(Text, { style: explorerStyles.infoValue, children: [
+          "Query executed successfully. ",
+          result.rowCount,
+          " row",
+          result.rowCount === 1 ? "" : "s",
+          " in ",
+          result.durationMs.toFixed(1),
+          " ms."
+        ] });
+      }
+      return /* @__PURE__ */ jsx(Text, { style: explorerStyles.placeholder, children: "Messages and errors appear here." });
+    }
+    if (!result) {
+      return /* @__PURE__ */ jsx(View, { style: explorerStyles.sqlResultsEmpty, children: /* @__PURE__ */ jsx(Text, { style: [explorerStyles.placeholder, { marginTop: 0 }], children: "Run a query to see results." }) });
+    }
+    if (result.columns.length === 0) {
+      return /* @__PURE__ */ jsx(View, { style: explorerStyles.sqlResultsEmpty, children: /* @__PURE__ */ jsxs(Text, { style: [explorerStyles.placeholder, { marginTop: 0 }], children: [
+        "Query completed with no result set (",
+        result.durationMs.toFixed(1),
+        " ms)."
+      ] }) });
+    }
+    return /* @__PURE__ */ jsx(
+      MobileDataView,
+      {
+        columns: result.columns,
+        dataKey: String(resultKey),
+        defaultMode: "table",
+        metaSuffix: `${result.durationMs.toFixed(1)} ms`,
+        rows: result.rows
+      }
+    );
+  };
+  return /* @__PURE__ */ jsxs(View, { style: explorerStyles.sqlTabRoot, children: [
+    /* @__PURE__ */ jsxs(View, { style: explorerStyles.sqlQueryPane, children: [
+      /* @__PURE__ */ jsx(Text, { style: explorerStyles.sectionTitle, children: "SQL (read-only)" }),
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          autoCapitalize: "none",
+          autoCorrect: false,
+          multiline: true,
+          onChangeText: setSql,
+          scrollEnabled: true,
+          style: explorerStyles.sqlInputCompact,
+          value: sql
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Pressable,
+        {
+          disabled: running,
+          onPress: () => void runQuery(),
+          style: [explorerStyles.primaryButton, running && explorerStyles.primaryButtonDisabled],
+          children: running ? /* @__PURE__ */ jsx(ActivityIndicator, { color: "#f8fafc" }) : /* @__PURE__ */ jsx(Text, { style: explorerStyles.primaryButtonLabel, children: "Run query" })
+        }
+      ),
+      /* @__PURE__ */ jsx(Text, { style: [explorerStyles.hintText, { marginTop: 0 }], children: "Allowed: SELECT, PRAGMA, EXPLAIN, WITH. Writes are blocked in DevTools." })
+    ] }),
+    /* @__PURE__ */ jsxs(View, { style: [explorerStyles.tabRow, { flexShrink: 0 }], children: [
+      /* @__PURE__ */ jsx(
+        Pressable,
+        {
+          onPress: () => setPanel("results"),
+          style: [explorerStyles.tab, panel === "results" && explorerStyles.tabActive],
+          children: /* @__PURE__ */ jsxs(
+            Text,
+            {
+              style: [explorerStyles.tabLabel, panel === "results" && explorerStyles.tabLabelActive],
+              children: [
+                "Results",
+                result ? ` (${result.rowCount})` : ""
+              ]
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Pressable,
+        {
+          onPress: () => setPanel("output"),
+          style: [explorerStyles.tab, panel === "output" && explorerStyles.tabActive],
+          children: /* @__PURE__ */ jsx(
+            Text,
+            {
+              style: [explorerStyles.tabLabel, panel === "output" && explorerStyles.tabLabelActive],
+              children: "Output"
+            }
+          )
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsx(View, { style: explorerStyles.sqlResultsPane, children: renderResultsContent() })
+  ] });
+}
+function ExplorerTableDetail({ inspector, tableName, onBack }) {
+  const [view, setView] = useState("data");
+  const [columns, setColumns] = useState([]);
+  const [pageResult, setPageResult] = useState(null);
+  const [search, setSearch] = useState("");
+  const [page, setPage] = useState(1);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const loadData = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const nextColumns = await inspector.getTableColumns(tableName);
+      setColumns(nextColumns);
+      const result = await inspector.fetchTablePage({
+        table: tableName,
+        page,
+        pageSize: DEFAULT_PAGE_SIZE,
+        search
+      });
+      setPageResult(result);
+    } catch (loadError) {
+      setError(loadError instanceof Error ? loadError.message : "Failed to load table");
+    } finally {
+      setLoading(false);
+    }
+  }, [inspector, page, search, tableName]);
+  useEffect(() => {
+    void loadData();
+  }, [loadData]);
+  const totalPages = pageResult ? Math.max(1, Math.ceil(pageResult.totalCount / pageResult.pageSize)) : 1;
+  return /* @__PURE__ */ jsxs(View, { style: explorerStyles.fullScreen, children: [
+    /* @__PURE__ */ jsxs(View, { style: explorerStyles.header, children: [
+      /* @__PURE__ */ jsx(Pressable, { onPress: onBack, children: /* @__PURE__ */ jsx(Text, { style: explorerStyles.headerAction, children: "\u2190 Back" }) }),
+      /* @__PURE__ */ jsx(Text, { style: explorerStyles.headerTitle, children: tableName }),
+      /* @__PURE__ */ jsx(View, { style: { width: 48 } })
+    ] }),
+    /* @__PURE__ */ jsxs(View, { style: [explorerStyles.subTabRow, { paddingHorizontal: 16, paddingTop: 12 }], children: [
+      /* @__PURE__ */ jsx(
+        Pressable,
+        {
+          onPress: () => setView("data"),
+          style: [explorerStyles.subTab, view === "data" && explorerStyles.subTabActive],
+          children: /* @__PURE__ */ jsx(Text, { style: [explorerStyles.subTabLabel, view === "data" && explorerStyles.subTabLabelActive], children: "Data" })
+        }
+      ),
+      /* @__PURE__ */ jsx(
+        Pressable,
+        {
+          onPress: () => setView("schema"),
+          style: [explorerStyles.subTab, view === "schema" && explorerStyles.subTabActive],
+          children: /* @__PURE__ */ jsx(
+            Text,
+            {
+              style: [explorerStyles.subTabLabel, view === "schema" && explorerStyles.subTabLabelActive],
+              children: "Schema"
+            }
+          )
+        }
+      )
+    ] }),
+    view === "data" ? /* @__PURE__ */ jsxs(View, { style: tableStyles.detailBody, children: [
+      /* @__PURE__ */ jsx(
+        TextInput,
+        {
+          autoCapitalize: "none",
+          autoCorrect: false,
+          onChangeText: (value) => {
+            setSearch(value);
+            setPage(1);
+          },
+          placeholder: "Search rows\u2026",
+          style: explorerStyles.searchInput,
+          value: search
+        }
+      ),
+      loading ? /* @__PURE__ */ jsx(ActivityIndicator, { style: { marginTop: 24 } }) : error ? /* @__PURE__ */ jsx(Text, { style: explorerStyles.errorText, children: error }) : pageResult ? /* @__PURE__ */ jsxs(Fragment, { children: [
+        /* @__PURE__ */ jsx(View, { style: tableStyles.detailDataPane, children: /* @__PURE__ */ jsx(
+          MobileDataView,
+          {
+            columns: pageResult.columns,
+            dataKey: `${tableName}-${page}-${search}`,
+            defaultMode: "table",
+            metaSuffix: `page ${page} of ${totalPages}`,
+            rows: pageResult.rows
+          }
+        ) }),
+        /* @__PURE__ */ jsxs(View, { style: explorerStyles.paginationRow, children: [
+          /* @__PURE__ */ jsx(Pressable, { disabled: page <= 1, onPress: () => setPage((current) => current - 1), children: /* @__PURE__ */ jsx(Text, { style: explorerStyles.headerAction, children: "Previous" }) }),
+          /* @__PURE__ */ jsxs(Text, { style: explorerStyles.paginationLabel, children: [
+            "Page ",
+            page,
+            " of ",
+            totalPages,
+            " \xB7 ",
+            pageResult.totalCount.toLocaleString(),
+            " rows"
+          ] }),
+          /* @__PURE__ */ jsx(
+            Pressable,
+            {
+              disabled: page >= totalPages,
+              onPress: () => setPage((current) => current + 1),
+              children: /* @__PURE__ */ jsx(Text, { style: explorerStyles.headerAction, children: "Next" })
+            }
+          )
+        ] })
+      ] }) : null
+    ] }) : /* @__PURE__ */ jsx(ScrollView, { contentContainerStyle: explorerStyles.content, children: columns.length === 0 ? /* @__PURE__ */ jsx(Text, { style: explorerStyles.placeholder, children: "No schema information." }) : columns.map((column) => /* @__PURE__ */ jsx(View, { style: explorerStyles.listItem, children: /* @__PURE__ */ jsxs(View, { style: { flex: 1 }, children: [
+      /* @__PURE__ */ jsx(Text, { style: explorerStyles.listItemTitle, children: column.name }),
+      /* @__PURE__ */ jsxs(Text, { style: explorerStyles.listItemMeta, children: [
+        column.type,
+        column.pk ? " \xB7 PK" : "",
+        column.notNull ? " \xB7 NOT NULL" : "",
+        column.defaultValue ? ` \xB7 DEFAULT ${column.defaultValue}` : ""
+      ] })
+    ] }) }, column.name)) })
+  ] });
+}
+function ExplorerTablesTab({
+  tables,
+  loading,
+  error,
+  onSelectTable
+}) {
+  const [search, setSearch] = useState("");
+  const filtered = useMemo(() => {
+    const term = search.trim().toLowerCase();
+    if (!term) {
+      return tables;
+    }
+    return tables.filter((table) => table.name.toLowerCase().includes(term));
+  }, [search, tables]);
+  if (loading) {
+    return /* @__PURE__ */ jsx(Text, { style: explorerStyles.placeholder, children: "Loading tables\u2026" });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsx(Text, { style: explorerStyles.errorText, children: error });
+  }
+  return /* @__PURE__ */ jsxs(View, { style: { flex: 1, padding: 16 }, children: [
+    /* @__PURE__ */ jsx(
+      TextInput,
+      {
+        autoCapitalize: "none",
+        autoCorrect: false,
+        onChangeText: setSearch,
+        placeholder: "Filter tables\u2026",
+        style: explorerStyles.searchInput,
+        value: search
+      }
+    ),
+    filtered.length === 0 ? /* @__PURE__ */ jsx(Text, { style: explorerStyles.placeholder, children: "No tables match your search." }) : /* @__PURE__ */ jsx(
+      FlatList,
+      {
+        data: filtered,
+        keyExtractor: (item) => item.name,
+        style: { flex: 1 },
+        renderItem: ({ item }) => /* @__PURE__ */ jsxs(Pressable, { onPress: () => onSelectTable(item.name), style: explorerStyles.listItem, children: [
+          /* @__PURE__ */ jsxs(View, { children: [
+            /* @__PURE__ */ jsx(Text, { style: explorerStyles.listItemTitle, children: item.name }),
+            /* @__PURE__ */ jsxs(Text, { style: explorerStyles.listItemMeta, children: [
+              item.rowCount.toLocaleString(),
+              " row",
+              item.rowCount === 1 ? "" : "s"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsx(Text, { style: explorerStyles.listItemMeta, children: "\u203A" })
+        ] })
+      }
+    )
+  ] });
+}
+function MobileDatabaseExplorer() {
+  const { explorerVisible, closeExplorer, mobileInspector } = useDevTools();
+  const [tab, setTab] = useState("overview");
+  const [screen, setScreen] = useState({ kind: "tabs" });
+  const [info, setInfo] = useState(null);
+  const [tables, setTables] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const loadOverview = useCallback(async () => {
+    if (!mobileInspector) {
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      const [nextInfo, nextTables] = await Promise.all([
+        mobileInspector.getDatabaseInfo(),
+        mobileInspector.listTables()
+      ]);
+      setInfo(nextInfo);
+      setTables(nextTables);
+    } catch (loadError) {
+      setError(loadError instanceof Error ? loadError.message : "Failed to load database");
+    } finally {
+      setLoading(false);
+    }
+  }, [mobileInspector]);
+  useEffect(() => {
+    if (!explorerVisible) {
+      setScreen({ kind: "tabs" });
+      setTab("overview");
+      return;
+    }
+    void loadOverview();
+  }, [explorerVisible, loadOverview]);
+  if (!mobileInspector) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(Modal, { animationType: "slide", onRequestClose: closeExplorer, visible: explorerVisible, children: screen.kind === "table" ? /* @__PURE__ */ jsx(
+    ExplorerTableDetail,
+    {
+      inspector: mobileInspector,
+      onBack: () => setScreen({ kind: "tabs" }),
+      tableName: screen.tableName
+    }
+  ) : /* @__PURE__ */ jsxs(View, { style: explorerStyles.fullScreen, children: [
+    /* @__PURE__ */ jsxs(View, { style: explorerStyles.header, children: [
+      /* @__PURE__ */ jsx(Text, { style: explorerStyles.headerTitle, children: "Database Explorer" }),
+      /* @__PURE__ */ jsx(Pressable, { accessibilityLabel: "Close database explorer", onPress: closeExplorer, children: /* @__PURE__ */ jsx(Text, { style: explorerStyles.headerAction, children: "Close" }) })
+    ] }),
+    /* @__PURE__ */ jsx(View, { style: explorerStyles.tabRow, children: ["overview", "tables", "sql"].map((item) => /* @__PURE__ */ jsx(
+      Pressable,
+      {
+        onPress: () => setTab(item),
+        style: [explorerStyles.tab, tab === item && explorerStyles.tabActive],
+        children: /* @__PURE__ */ jsx(
+          Text,
+          {
+            style: [explorerStyles.tabLabel, tab === item && explorerStyles.tabLabelActive],
+            children: item === "overview" ? "Overview" : item === "tables" ? "Tables" : "SQL"
+          }
+        )
+      },
+      item
+    )) }),
+    /* @__PURE__ */ jsxs(View, { style: { flex: 1 }, children: [
+      tab === "overview" && /* @__PURE__ */ jsx(
+        ExplorerOverviewTab,
+        {
+          error,
+          info,
+          loading,
+          onOpenSql: () => setTab("sql"),
+          onOpenTables: () => setTab("tables")
+        }
+      ),
+      tab === "tables" && /* @__PURE__ */ jsx(
+        ExplorerTablesTab,
+        {
+          error,
+          loading,
+          onSelectTable: (tableName) => setScreen({ kind: "table", tableName }),
+          tables
+        }
+      ),
+      tab === "sql" && /* @__PURE__ */ jsx(ExplorerSqlTab, { inspector: mobileInspector })
+    ] })
+  ] }) });
+}
+function DatabaseDevTools({
+  database,
+  type,
+  adapter,
+  serverUrl,
+  enabled,
+  position = "bottom-right",
+  draggable = true,
+  snapToEdges = true,
+  floatingPosition,
+  onFloatingPositionChange,
+  style,
+  onConnectionStateChange
+}) {
+  if (!isDevToolsEnabled(enabled)) {
+    return null;
+  }
+  return /* @__PURE__ */ jsx(
+    DevToolsProvider,
+    {
+      adapter,
+      database,
+      onConnectionStateChange,
+      serverUrl,
+      type,
+      children: /* @__PURE__ */ jsxs(View, { pointerEvents: "box-none", style: StyleSheet.absoluteFill, children: [
+        /* @__PURE__ */ jsx(
+          FloatingDevToolsButton,
+          {
+            draggable,
+            floatingPosition,
+            iconStyle: style,
+            onFloatingPositionChange,
+            position,
+            snapToEdges
+          }
+        ),
+        /* @__PURE__ */ jsx(DevToolsLauncherModal, {}),
+        /* @__PURE__ */ jsx(DevToolsSettingsModal, {}),
+        /* @__PURE__ */ jsx(MobileDatabaseExplorer, {})
+      ] })
+    }
+  );
+}
+
+export { DatabaseDevTools, createExpoSqliteInspector, handleBeginTransaction, handleCommitTransaction, handleExecuteWrite, handleRollbackTransaction, isEditableDatabaseAdapter, isWritableDatabaseAdapter };
+//# sourceMappingURL=chunk-7UY2LDRW.js.map
+//# sourceMappingURL=chunk-7UY2LDRW.js.map