database-devtools 0.1.1 → 0.1.2

package/dist/native.cjs

@@ -0,0 +1,3946 @@
+'use strict';
+
+var reactNative = require('react-native');
+var react = require('react');
+var jsxRuntime = require('react/jsx-runtime');
+var MaterialCommunityIcons = require('@expo/vector-icons/MaterialCommunityIcons');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var MaterialCommunityIcons__default = /*#__PURE__*/_interopDefault(MaterialCommunityIcons);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/types/protocol.ts
+var DevToolsRole = {
+  MOBILE: "mobile",
+  BROWSER: "browser"
+};
+var MessageType = {
+  REGISTER: "register",
+  PING: "ping",
+  PONG: "pong",
+  DEVICE_STATUS: "deviceStatus",
+  BROADCAST: "broadcast",
+  REFRESH_REQUEST: "refreshRequest",
+  SNAPSHOT_UPLOAD_REQUESTED: "snapshotUploadRequested",
+  REFRESH_STATUS: "refreshStatus",
+  SNAPSHOT_READY: "snapshotReady",
+  REFRESH_ERROR: "refreshError",
+  EXPORT_SNAPSHOT_REQUEST: "exportSnapshotRequest",
+  EXPORT_SNAPSHOT_ERROR: "exportSnapshotError",
+  BEGIN_TRANSACTION_REQUEST: "beginTransactionRequest",
+  COMMIT_TRANSACTION_REQUEST: "commitTransactionRequest",
+  ROLLBACK_TRANSACTION_REQUEST: "rollbackTransactionRequest",
+  WRITE_REQUEST: "writeRequest",
+  BEGIN_TRANSACTION: "beginTransaction",
+  COMMIT_TRANSACTION: "commitTransaction",
+  ROLLBACK_TRANSACTION: "rollbackTransaction",
+  EXECUTE_WRITE: "executeWrite",
+  TRANSACTION_ACK: "transactionAck",
+  WRITE_ACK: "writeAck",
+  TRANSACTION_STATUS: "transactionStatus",
+  WRITE_RESULT: "writeResult",
+  WRITE_ERROR: "writeError"
+};
+var DEVTOOLS_WS_PATH = "/ws";
+var DEFAULT_DEVTOOLS_PORT = 3847;
+var DEFAULT_DEVTOOLS_HOST = "0.0.0.0";
+var HEARTBEAT_INTERVAL_MS = 3e4;
+var HEARTBEAT_TIMEOUT_MS = 1e4;
+var DEVICE_SNAPSHOT_API_PATH = "/api/devices";
+var SNAPSHOT_API_PATH = DEVICE_SNAPSHOT_API_PATH;
+var REFRESH_TIMEOUT_MS = 6e4;
+var SYNC_TIMEOUT_MS = REFRESH_TIMEOUT_MS;
+var MAX_SNAPSHOT_BYTES = 50 * 1024 * 1024;
+function createMessage(message) {
+  return { ...message, timestamp: Date.now() };
+}
+function buildDevToolsHttpUrl(host = "localhost", port = DEFAULT_DEVTOOLS_PORT) {
+  return `http://${host}:${port}`;
+}
+function buildDevToolsWsUrl(host = "localhost", port = DEFAULT_DEVTOOLS_PORT) {
+  return `ws://${host}:${port}${DEVTOOLS_WS_PATH}`;
+}
+function buildDeviceSnapshotUrl(httpBaseUrl, deviceId) {
+  const base = httpBaseUrl.replace(/\/$/, "");
+  return `${base}${DEVICE_SNAPSHOT_API_PATH}/${encodeURIComponent(deviceId)}/snapshot`;
+}
+function buildSnapshotUrl(httpBaseUrl, deviceId) {
+  return buildDeviceSnapshotUrl(httpBaseUrl, deviceId);
+}
+function wsUrlToHttpUrl(wsUrl) {
+  const url = new URL(wsUrl);
+  url.protocol = url.protocol === "wss:" ? "https:" : "http:";
+  url.pathname = "";
+  url.search = "";
+  url.hash = "";
+  return url.toString().replace(/\/$/, "");
+}
+function hasMessageType(value) {
+  return typeof value === "object" && value !== null && typeof value.type === "string";
+}
+function isRegisterMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.REGISTER) {
+    return false;
+  }
+  const message = value;
+  return message.role === DevToolsRole.MOBILE || message.role === DevToolsRole.BROWSER;
+}
+function isPongMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.PONG) {
+    return false;
+  }
+  const message = value;
+  return typeof message.pingId === "string";
+}
+function isRefreshRequestMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.REFRESH_REQUEST) {
+    return false;
+  }
+  const message = value;
+  return typeof message.deviceId === "string" && message.refreshType === "snapshot";
+}
+function isSnapshotUploadRequestedMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.SNAPSHOT_UPLOAD_REQUESTED) {
+    return false;
+  }
+  const message = value;
+  return typeof message.deviceId === "string" && message.refreshType === "snapshot";
+}
+function isRefreshStatusMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.REFRESH_STATUS) {
+    return false;
+  }
+  const message = value;
+  return typeof message.deviceId === "string" && typeof message.state === "string";
+}
+function isSnapshotReadyMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.SNAPSHOT_READY) {
+    return false;
+  }
+  const message = value;
+  return typeof message.deviceId === "string" && typeof message.size === "number" && typeof message.exportedAt === "number" && typeof message.kind === "string" && typeof message.mimeType === "string";
+}
+function isRefreshErrorMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.REFRESH_ERROR) {
+    return false;
+  }
+  const message = value;
+  return typeof message.deviceId === "string" && typeof message.code === "string";
+}
+function isExportSnapshotRequestMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.EXPORT_SNAPSHOT_REQUEST) {
+    return false;
+  }
+  const message = value;
+  return message.refreshType === "snapshot";
+}
+function isExportSnapshotErrorMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.EXPORT_SNAPSHOT_ERROR) {
+    return false;
+  }
+  const message = value;
+  return typeof message.code === "string" && typeof message.message === "string";
+}
+function isBeginTransactionRequestMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.BEGIN_TRANSACTION_REQUEST) {
+    return false;
+  }
+  const message = value;
+  return typeof message.transactionId === "string" && typeof message.deviceId === "string";
+}
+function isCommitTransactionRequestMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.COMMIT_TRANSACTION_REQUEST) {
+    return false;
+  }
+  const message = value;
+  return typeof message.transactionId === "string" && typeof message.deviceId === "string";
+}
+function isRollbackTransactionRequestMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.ROLLBACK_TRANSACTION_REQUEST) {
+    return false;
+  }
+  const message = value;
+  return typeof message.transactionId === "string" && typeof message.deviceId === "string";
+}
+function isWriteRequestMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.WRITE_REQUEST) {
+    return false;
+  }
+  const message = value;
+  return typeof message.writeId === "string" && typeof message.transactionId === "string" && typeof message.deviceId === "string" && typeof message.operation === "object" && message.operation !== null;
+}
+function isTransactionAckMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.TRANSACTION_ACK) {
+    return false;
+  }
+  const message = value;
+  return typeof message.transactionId === "string" && (message.action === "begin" || message.action === "commit" || message.action === "rollback") && typeof message.ok === "boolean";
+}
+function isWriteAckMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.WRITE_ACK) {
+    return false;
+  }
+  const message = value;
+  return typeof message.writeId === "string" && typeof message.transactionId === "string" && typeof message.ok === "boolean";
+}
+function isClientMessage(value) {
+  return isRegisterMessage(value) || isPongMessage(value) || isRefreshRequestMessage(value) || isExportSnapshotRequestMessage(value) || isBeginTransactionRequestMessage(value) || isCommitTransactionRequestMessage(value) || isRollbackTransactionRequestMessage(value) || isWriteRequestMessage(value) || isTransactionAckMessage(value) || isWriteAckMessage(value);
+}
+function isPingMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.PING) {
+    return false;
+  }
+  const message = value;
+  return typeof message.pingId === "string";
+}
+function isDeviceStatusMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.DEVICE_STATUS) {
+    return false;
+  }
+  const message = value;
+  return typeof message.payload === "object" && message.payload !== null;
+}
+function isBroadcastMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.BROADCAST) {
+    return false;
+  }
+  return true;
+}
+function isBeginTransactionMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.BEGIN_TRANSACTION) {
+    return false;
+  }
+  const message = value;
+  return typeof message.transactionId === "string";
+}
+function isCommitTransactionMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.COMMIT_TRANSACTION) {
+    return false;
+  }
+  const message = value;
+  return typeof message.transactionId === "string";
+}
+function isRollbackTransactionMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.ROLLBACK_TRANSACTION) {
+    return false;
+  }
+  const message = value;
+  return typeof message.transactionId === "string";
+}
+function isExecuteWriteMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.EXECUTE_WRITE) {
+    return false;
+  }
+  const message = value;
+  return typeof message.writeId === "string" && typeof message.transactionId === "string" && typeof message.operation === "object" && message.operation !== null;
+}
+function isTransactionStatusMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.TRANSACTION_STATUS) {
+    return false;
+  }
+  const message = value;
+  return typeof message.transactionId === "string" && typeof message.deviceId === "string" && typeof message.state === "string";
+}
+function isWriteResultMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.WRITE_RESULT) {
+    return false;
+  }
+  const message = value;
+  return typeof message.writeId === "string" && typeof message.transactionId === "string" && typeof message.rowsAffected === "number";
+}
+function isWriteErrorMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.WRITE_ERROR) {
+    return false;
+  }
+  const message = value;
+  return typeof message.transactionId === "string" && typeof message.code === "string";
+}
+function isServerMessage(value) {
+  return isPingMessage(value) || isDeviceStatusMessage(value) || isBroadcastMessage(value) || isSnapshotUploadRequestedMessage(value) || isRefreshStatusMessage(value) || isSnapshotReadyMessage(value) || isRefreshErrorMessage(value) || isExportSnapshotErrorMessage(value) || isBeginTransactionMessage(value) || isCommitTransactionMessage(value) || isRollbackTransactionMessage(value) || isExecuteWriteMessage(value) || isTransactionStatusMessage(value) || isWriteResultMessage(value) || isWriteErrorMessage(value);
+}
+
+// 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/types/kind.ts
+var DATABASE_DEVTOOLS_KIND = /* @__PURE__ */ Symbol.for("@database-devtools/kind");
+function readDatabaseKindMarker(value) {
+  if (typeof value !== "object" || value === null) {
+    return void 0;
+  }
+  const marker = value[DATABASE_DEVTOOLS_KIND];
+  return typeof marker === "string" ? marker : void 0;
+}
+
+// src/types/snapshot.ts
+var SNAPSHOT_KIND_HEADER = "x-database-kind";
+var SNAPSHOT_MIME_HEADER = "x-snapshot-mime-type";
+var SNAPSHOT_NAME_HEADER = "x-database-name";
+var SQLITE_SNAPSHOT_MIME_TYPE = "application/x-sqlite3";
+
+// src/adapter/errors.ts
+var AdapterResolutionError = class extends Error {
+  constructor(supported, hint) {
+    super(formatAdapterResolutionMessage(supported, hint));
+    this.supported = supported;
+    this.hint = hint;
+  }
+  supported;
+  hint;
+  name = "AdapterResolutionError";
+};
+function formatAdapterResolutionMessage(supported, hint) {
+  const lines = [
+    "Unable to determine the database type.",
+    "",
+    "Supported databases:",
+    ...supported.map((entry) => `  \u2022 ${entry.displayName}`),
+    "",
+    "Try specifying a type:",
+    '  <DatabaseDevTools database={db} type="sqlite" />',
+    "",
+    "Or provide a custom adapter:",
+    "  <DatabaseDevTools database={db} adapter={myAdapter} />"
+  ];
+  if (hint === "install-package") {
+    lines.push(
+      "",
+      "For SQLite, install expo-sqlite:",
+      "  npm install expo-sqlite"
+    );
+  }
+  return lines.join("\n");
+}
+
+// src/adapter/registry.ts
+var AdapterRegistry = class {
+  definitions = /* @__PURE__ */ new Map();
+  register(definition) {
+    this.definitions.set(definition.kind, definition);
+  }
+  get(kind) {
+    return this.definitions.get(kind);
+  }
+  listSupported() {
+    return [...this.definitions.values()].sort((left, right) => left.displayName.localeCompare(right.displayName)).map((definition) => ({
+      kind: definition.kind,
+      displayName: definition.displayName
+    }));
+  }
+  detect(database) {
+    const markerKind = readDatabaseKindMarker(database);
+    if (markerKind) {
+      const marked = this.definitions.get(markerKind);
+      if (marked) {
+        return marked;
+      }
+    }
+    const matches = [...this.definitions.values()].filter((definition) => {
+      try {
+        return definition.detect(database);
+      } catch {
+        return false;
+      }
+    }).sort((left, right) => right.priority - left.priority);
+    return matches[0];
+  }
+};
+var globalRegistry = null;
+function getAdapterRegistry() {
+  if (!globalRegistry) {
+    globalRegistry = new AdapterRegistry();
+  }
+  return globalRegistry;
+}
+
+// src/adapters/sqlite/buildWriteSql.ts
+var IDENTIFIER_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+function quoteIdentifier(name) {
+  if (!IDENTIFIER_PATTERN.test(name)) {
+    throw new Error(`Invalid identifier: ${name}`);
+  }
+  return `"${name.replace(/"/g, '""')}"`;
+}
+function buildInsertSql(operation) {
+  const columns = Object.keys(operation.values);
+  if (columns.length === 0) {
+    throw new Error("Insert requires at least one column value");
+  }
+  const quotedColumns = columns.map(quoteIdentifier).join(", ");
+  const placeholders = columns.map(() => "?").join(", ");
+  const sql = `INSERT INTO ${quoteIdentifier(operation.table)} (${quotedColumns}) VALUES (${placeholders})`;
+  const params = columns.map((column) => operation.values[column] ?? null);
+  return { sql, params };
+}
+function buildUpdateSql(operation) {
+  const valueColumns = Object.keys(operation.values);
+  const pkColumns = Object.keys(operation.primaryKey);
+  if (valueColumns.length === 0) {
+    throw new Error("Update requires at least one column value");
+  }
+  if (pkColumns.length === 0) {
+    throw new Error("Update requires a primary key");
+  }
+  const setClause = valueColumns.map((column) => `${quoteIdentifier(column)} = ?`).join(", ");
+  const whereClause = pkColumns.map((column) => `${quoteIdentifier(column)} = ?`).join(" AND ");
+  const sql = `UPDATE ${quoteIdentifier(operation.table)} SET ${setClause} WHERE ${whereClause}`;
+  const params = [
+    ...valueColumns.map((column) => operation.values[column] ?? null),
+    ...pkColumns.map((column) => operation.primaryKey[column] ?? null)
+  ];
+  return { sql, params };
+}
+function buildDeleteSql(operation) {
+  const pkColumns = Object.keys(operation.primaryKey);
+  if (pkColumns.length === 0) {
+    throw new Error("Delete requires a primary key");
+  }
+  const whereClause = pkColumns.map((column) => `${quoteIdentifier(column)} = ?`).join(" AND ");
+  const sql = `DELETE FROM ${quoteIdentifier(operation.table)} WHERE ${whereClause}`;
+  const params = pkColumns.map((column) => operation.primaryKey[column] ?? null);
+  return { sql, params };
+}
+
+// src/adapters/sqlite/createExpoSqliteAdapter.ts
+function createExpoSqliteAdapter(options) {
+  const { database } = options;
+  let inTransaction = false;
+  let operationQueue = Promise.resolve();
+  const enqueue = async (operation) => {
+    const next = operationQueue.then(operation);
+    operationQueue = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  };
+  const assertTransaction = () => {
+    if (!inTransaction) {
+      throw new Error("No open transaction. Call beginTransaction() first.");
+    }
+  };
+  const runWrite = async (operation) => {
+    assertTransaction();
+    let sql;
+    let params;
+    switch (operation.kind) {
+      case "insert": {
+        const built = buildInsertSql(operation);
+        sql = built.sql;
+        params = built.params;
+        break;
+      }
+      case "update": {
+        const built = buildUpdateSql(operation);
+        sql = built.sql;
+        params = built.params;
+        break;
+      }
+      case "delete": {
+        const built = buildDeleteSql(operation);
+        sql = built.sql;
+        params = built.params;
+        break;
+      }
+      default: {
+        const exhaustive = operation;
+        throw new Error(`Unsupported write operation: ${exhaustive.kind}`);
+      }
+    }
+    const result = await database.runAsync(sql, params);
+    return { rowsAffected: result.changes };
+  };
+  return {
+    kind: "sqlite",
+    dialect: "sqlite",
+    id: options.id ?? database.databasePath,
+    name: options.name ?? "SQLite",
+    capabilities: {
+      exportSnapshot: true,
+      executeQuery: false,
+      listTables: false,
+      getSchema: false,
+      transactionalWrites: true,
+      observeChanges: false,
+      importSnapshot: false
+    },
+    async exportSnapshot() {
+      return enqueue(async () => {
+        if (inTransaction) {
+          throw new Error("Cannot export while a write transaction is open");
+        }
+        await database.execAsync("PRAGMA wal_checkpoint(FULL)");
+        const bytes = await database.serializeAsync();
+        return {
+          bytes,
+          mimeType: SQLITE_SNAPSHOT_MIME_TYPE,
+          kind: "sqlite",
+          exportedAt: Date.now()
+        };
+      });
+    },
+    async beginTransaction() {
+      return enqueue(async () => {
+        if (inTransaction) {
+          throw new Error("Transaction already open");
+        }
+        await database.execAsync("BEGIN IMMEDIATE");
+        inTransaction = true;
+      });
+    },
+    async commitTransaction() {
+      return enqueue(async () => {
+        assertTransaction();
+        try {
+          await database.execAsync("COMMIT");
+        } finally {
+          inTransaction = false;
+        }
+      });
+    },
+    async rollbackTransaction() {
+      return enqueue(async () => {
+        if (!inTransaction) {
+          return;
+        }
+        try {
+          await database.execAsync("ROLLBACK");
+        } finally {
+          inTransaction = false;
+        }
+      });
+    },
+    executeWrite: (operation) => enqueue(() => runWrite(operation))
+  };
+}
+
+// src/adapters/sqlite/detect.ts
+function detectExpoSqlite(database) {
+  return typeof database === "object" && database !== null && typeof database.execAsync === "function" && typeof database.serializeAsync === "function" && typeof database.runAsync === "function" && typeof database.databasePath === "string";
+}
+function detectExpoSqliteInspectable(database) {
+  return detectExpoSqlite(database) && typeof database.getAllAsync === "function" && typeof database.getFirstAsync === "function";
+}
+
+// src/adapters/sqlite/register.ts
+var sqliteAdapterDefinition = {
+  kind: "sqlite",
+  displayName: "SQLite",
+  priority: 100,
+  detect: detectExpoSqlite,
+  create: (database) => createExpoSqliteAdapter({
+    database,
+    name: database.databasePath
+  })
+};
+function registerSqliteAdapter() {
+  getAdapterRegistry().register(sqliteAdapterDefinition);
+}
+
+// src/adapter/registerBuiltins.ts
+async function registerBuiltInAdapters() {
+  registerSqliteAdapter();
+}
+
+// src/adapter/resolveAdapter.ts
+async function resolveAdapter(database, options = {}) {
+  if (options.adapter) {
+    return options.adapter;
+  }
+  if (!database) {
+    throw new AdapterResolutionError([], "adapter");
+  }
+  await registerBuiltInAdapters();
+  const registry = getAdapterRegistry();
+  if (options.type) {
+    const definition = registry.get(options.type);
+    if (!definition) {
+      throw new AdapterResolutionError(registry.listSupported(), "type");
+    }
+    return definition.create(database);
+  }
+  const detected = registry.detect(database);
+  if (!detected) {
+    throw new AdapterResolutionError(
+      registry.listSupported(),
+      registry.listSupported().length === 0 ? "install-package" : "type"
+    );
+  }
+  return detected.create(database);
+}
+
+// src/inspector/registry.ts
+var InspectorRegistry = class {
+  definitions = /* @__PURE__ */ new Map();
+  register(definition) {
+    this.definitions.set(definition.kind, definition);
+  }
+  get(kind) {
+    return this.definitions.get(kind);
+  }
+  listSupported() {
+    return [...this.definitions.values()].sort((left, right) => left.displayName.localeCompare(right.displayName)).map((definition) => ({
+      kind: definition.kind,
+      displayName: definition.displayName
+    }));
+  }
+  detectFromBytes(bytes) {
+    return [...this.definitions.values()].find((definition) => definition.canOpenBytes?.(bytes));
+  }
+  detectFromSnapshot(input) {
+    const byKind = this.definitions.get(input.kind);
+    if (byKind) {
+      return byKind;
+    }
+    return [...this.definitions.values()].find(
+      (definition) => definition.mimeTypes.includes(input.mimeType)
+    );
+  }
+};
+var globalInspectorRegistry = null;
+function getInspectorRegistry() {
+  if (!globalInspectorRegistry) {
+    globalInspectorRegistry = new InspectorRegistry();
+  }
+  return globalInspectorRegistry;
+}
+async function createInspectorForSnapshot(input) {
+  const registry = getInspectorRegistry();
+  const definition = registry.get(input.kind) ?? registry.detectFromBytes(input.bytes) ?? registry.detectFromSnapshot(input);
+  if (!definition) {
+    throw new Error(`No inspector registered for database kind "${input.kind}"`);
+  }
+  const inspector = await definition.createInspector();
+  await inspector.open(input.bytes);
+  return inspector;
+}
+
+// src/utils/ids.ts
+function generateDeviceId() {
+  return generateUniqueId("device");
+}
+function generateTransactionId() {
+  return generateUniqueId("txn");
+}
+function generateWriteId() {
+  return generateUniqueId("write");
+}
+function generateUniqueId(prefix) {
+  if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
+    return `${prefix}-${crypto.randomUUID()}`;
+  }
+  const random = Math.random().toString(36).slice(2, 10);
+  return `${prefix}-${Date.now()}-${random}`;
+}
+
+// src/utils/reconnect.ts
+var DEFAULT_BASE_MS = 1e3;
+var DEFAULT_MAX_MS = 3e4;
+var DEFAULT_JITTER_MS = 500;
+function calculateBackoffDelay(attempt, options = {}) {
+  const baseMs = options.baseMs ?? DEFAULT_BASE_MS;
+  const maxMs = options.maxMs ?? DEFAULT_MAX_MS;
+  const jitterMs = options.jitterMs ?? DEFAULT_JITTER_MS;
+  const exponential = baseMs * 2 ** attempt;
+  const capped = Math.min(exponential, maxMs);
+  const jitter = Math.floor(Math.random() * jitterMs);
+  return capped + jitter;
+}
+var ReconnectScheduler = class {
+  attempt = 0;
+  timer = null;
+  onReconnect;
+  options;
+  constructor({ onReconnect, ...options }) {
+    this.onReconnect = onReconnect;
+    this.options = options;
+  }
+  schedule() {
+    if (this.timer !== null) {
+      return;
+    }
+    const delay = calculateBackoffDelay(this.attempt, this.options);
+    this.attempt += 1;
+    this.timer = setTimeout(() => {
+      this.timer = null;
+      this.onReconnect();
+    }, delay);
+  }
+  reset() {
+    this.attempt = 0;
+    this.cancel();
+  }
+  cancel() {
+    if (this.timer !== null) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+};
+
+// src/client/createDevToolsClient.ts
+var WRITE_TIMEOUT_MS = 3e4;
+function createDevToolsClient(options = {}) {
+  const role = options.role ?? DevToolsRole.MOBILE;
+  const WebSocketImpl = options.WebSocketImpl ?? globalThis.WebSocket;
+  if (!WebSocketImpl) {
+    throw new Error("WebSocket is not available in this environment.");
+  }
+  let socket = null;
+  let deviceStatus = null;
+  let connectionState = "disconnected";
+  let lastConnectionError = null;
+  let intentionalDisconnect = false;
+  let transactionState = "idle";
+  let activeTransactionId = null;
+  let activeDeviceId = null;
+  const pendingTransaction = /* @__PURE__ */ new Map();
+  const pendingWrites = /* @__PURE__ */ new Map();
+  const deviceId = role === DevToolsRole.MOBILE ? options.deviceId ?? generateDeviceId() : void 0;
+  let wsUrl = options.serverUrl ?? buildDevToolsWsUrl("localhost", DEFAULT_DEVTOOLS_PORT);
+  const setConnectionState = (state) => {
+    if (connectionState === state) {
+      return;
+    }
+    connectionState = state;
+    options.onConnectionStateChange?.(state);
+  };
+  const setTransactionState = (state) => {
+    if (transactionState === state) {
+      return;
+    }
+    transactionState = state;
+    options.onTransactionStateChange?.(state);
+  };
+  const resetTransaction = () => {
+    setTransactionState("idle");
+    activeTransactionId = null;
+    activeDeviceId = null;
+  };
+  const rejectPendingTransaction = (transactionId, error) => {
+    const pending = pendingTransaction.get(transactionId);
+    if (pending) {
+      pending.reject(error);
+      pendingTransaction.delete(transactionId);
+    }
+  };
+  const rejectAllPending = (error) => {
+    for (const [id, pending] of pendingTransaction) {
+      pending.reject(error);
+      pendingTransaction.delete(id);
+    }
+    for (const [id, pending] of pendingWrites) {
+      pending.reject(error);
+      pendingWrites.delete(id);
+    }
+    resetTransaction();
+  };
+  const reconnectScheduler = new ReconnectScheduler({
+    onReconnect: () => {
+      openSocket();
+    }
+  });
+  const send = (message) => {
+    if (!socket || socket.readyState !== WebSocketImpl.OPEN) {
+      return;
+    }
+    socket.send(JSON.stringify({ ...message, timestamp: Date.now() }));
+  };
+  const sendRegister = () => {
+    send({
+      type: MessageType.REGISTER,
+      role,
+      ...deviceId ? { deviceId } : {},
+      ...options.metadata ? { metadata: options.metadata } : {}
+    });
+  };
+  const handleServerMessage = (parsed) => {
+    if (isPingMessage(parsed)) {
+      send({
+        type: MessageType.PONG,
+        pingId: parsed.pingId
+      });
+      return;
+    }
+    if (isDeviceStatusMessage(parsed)) {
+      deviceStatus = parsed.payload;
+      options.onDeviceStatus?.(parsed.payload);
+      return;
+    }
+    if (isSnapshotUploadRequestedMessage(parsed)) {
+      options.onSnapshotUploadRequested?.(parsed);
+      return;
+    }
+    if (isExportSnapshotErrorMessage(parsed)) {
+      options.onExportSnapshotError?.(parsed);
+      return;
+    }
+    if (isRefreshStatusMessage(parsed)) {
+      options.onRefreshStatus?.(parsed);
+      return;
+    }
+    if (isSnapshotReadyMessage(parsed)) {
+      options.onSnapshotReady?.(parsed);
+      return;
+    }
+    if (isRefreshErrorMessage(parsed)) {
+      options.onRefreshError?.(parsed);
+      return;
+    }
+    if (isBeginTransactionMessage(parsed)) {
+      options.onBeginTransaction?.(parsed);
+      return;
+    }
+    if (isCommitTransactionMessage(parsed)) {
+      options.onCommitTransaction?.(parsed);
+      return;
+    }
+    if (isRollbackTransactionMessage(parsed)) {
+      options.onRollbackTransaction?.(parsed);
+      return;
+    }
+    if (isExecuteWriteMessage(parsed)) {
+      options.onExecuteWrite?.(parsed);
+      return;
+    }
+    if (isTransactionStatusMessage(parsed)) {
+      options.onTransactionStatus?.(parsed);
+      if (role !== DevToolsRole.BROWSER) {
+        return;
+      }
+      const pending = pendingTransaction.get(parsed.transactionId);
+      if (parsed.state === "open" && pending?.action === "begin") {
+        setTransactionState("open");
+        activeTransactionId = parsed.transactionId;
+        activeDeviceId = parsed.deviceId;
+        pending.resolve();
+        pendingTransaction.delete(parsed.transactionId);
+        return;
+      }
+      if (parsed.state === "idle" && pending && (pending.action === "commit" || pending.action === "rollback")) {
+        resetTransaction();
+        pending.resolve();
+        pendingTransaction.delete(parsed.transactionId);
+        return;
+      }
+      if (parsed.state === "failed") {
+        rejectPendingTransaction(
+          parsed.transactionId,
+          new Error(parsed.message ?? "Transaction failed")
+        );
+        resetTransaction();
+      }
+      return;
+    }
+    if (isWriteResultMessage(parsed)) {
+      options.onWriteResult?.(parsed);
+      const pending = pendingWrites.get(parsed.writeId);
+      if (pending) {
+        pending.resolve({ rowsAffected: parsed.rowsAffected });
+        pendingWrites.delete(parsed.writeId);
+      }
+      return;
+    }
+    if (isWriteErrorMessage(parsed)) {
+      options.onWriteError?.(parsed);
+      const error = new Error(parsed.message);
+      if (parsed.writeId) {
+        const pendingWrite = pendingWrites.get(parsed.writeId);
+        if (pendingWrite) {
+          pendingWrite.reject(error);
+          pendingWrites.delete(parsed.writeId);
+        }
+      } else {
+        rejectPendingTransaction(parsed.transactionId, error);
+        resetTransaction();
+      }
+    }
+  };
+  const openSocket = () => {
+    if (socket && (socket.readyState === WebSocketImpl.OPEN || socket.readyState === WebSocketImpl.CONNECTING)) {
+      return;
+    }
+    setConnectionState(intentionalDisconnect ? "disconnected" : connectionState === "disconnected" ? "connecting" : "reconnecting");
+    socket = new WebSocketImpl(wsUrl);
+    socket.addEventListener("open", () => {
+      reconnectScheduler.reset();
+      lastConnectionError = null;
+      setConnectionState("connected");
+      options.onConnect?.();
+      sendRegister();
+    });
+    socket.addEventListener("message", (event) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      handleServerMessage(parsed);
+    });
+    socket.addEventListener("close", () => {
+      socket = null;
+      options.onDisconnect?.();
+      rejectAllPending(new Error("Disconnected from DevTools hub"));
+      if (intentionalDisconnect) {
+        setConnectionState("disconnected");
+        return;
+      }
+      setConnectionState("reconnecting");
+      reconnectScheduler.schedule();
+    });
+    socket.addEventListener("error", () => {
+      const error = new Error(`WebSocket connection failed: ${wsUrl}`);
+      lastConnectionError = error.message;
+      options.onError?.(error);
+    });
+  };
+  const connect = () => {
+    intentionalDisconnect = false;
+    openSocket();
+  };
+  const disconnect = () => {
+    intentionalDisconnect = true;
+    reconnectScheduler.cancel();
+    socket?.close();
+    socket = null;
+    rejectAllPending(new Error("Disconnected"));
+    setConnectionState("disconnected");
+  };
+  const setServerUrl = (url) => {
+    wsUrl = url;
+    const wasConnected = connectionState === "connected" || connectionState === "connecting" || connectionState === "reconnecting";
+    disconnect();
+    intentionalDisconnect = false;
+    if (wasConnected) {
+      connect();
+    }
+  };
+  const requestRefresh = (targetDeviceId) => {
+    send({
+      type: MessageType.REFRESH_REQUEST,
+      deviceId: targetDeviceId,
+      refreshType: "snapshot"
+    });
+  };
+  const requestExportSnapshot = () => {
+    send({
+      type: MessageType.EXPORT_SNAPSHOT_REQUEST,
+      refreshType: "snapshot"
+    });
+  };
+  const sendTransactionAck = (message) => {
+    send({
+      type: MessageType.TRANSACTION_ACK,
+      ...message
+    });
+  };
+  const sendWriteAck = (message) => {
+    send({
+      type: MessageType.WRITE_ACK,
+      ...message
+    });
+  };
+  const waitForTransaction = (transactionId, action) => {
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pendingTransaction.delete(transactionId);
+        reject(new Error(`Transaction ${action} timed out`));
+      }, WRITE_TIMEOUT_MS);
+      pendingTransaction.set(transactionId, {
+        action,
+        resolve: () => {
+          clearTimeout(timer);
+          resolve();
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+    });
+  };
+  const beginTransaction = async (targetDeviceId) => {
+    if (role !== DevToolsRole.BROWSER) {
+      throw new Error("beginTransaction is only available for browser clients");
+    }
+    if (transactionState !== "idle") {
+      throw new Error("A transaction is already active");
+    }
+    const transactionId = generateTransactionId();
+    setTransactionState("opening");
+    activeTransactionId = transactionId;
+    activeDeviceId = targetDeviceId;
+    const promise = waitForTransaction(transactionId, "begin");
+    send({
+      type: MessageType.BEGIN_TRANSACTION_REQUEST,
+      transactionId,
+      deviceId: targetDeviceId
+    });
+    await promise;
+  };
+  const commitTransaction = async () => {
+    if (role !== DevToolsRole.BROWSER) {
+      throw new Error("commitTransaction is only available for browser clients");
+    }
+    if (!activeTransactionId || !activeDeviceId || transactionState !== "open") {
+      throw new Error("No open transaction");
+    }
+    const transactionId = activeTransactionId;
+    const deviceIdForCommit = activeDeviceId;
+    setTransactionState("committing");
+    const promise = waitForTransaction(transactionId, "commit");
+    send({
+      type: MessageType.COMMIT_TRANSACTION_REQUEST,
+      transactionId,
+      deviceId: deviceIdForCommit
+    });
+    await promise;
+  };
+  const rollbackTransaction = async () => {
+    if (role !== DevToolsRole.BROWSER) {
+      throw new Error("rollbackTransaction is only available for browser clients");
+    }
+    if (!activeTransactionId || !activeDeviceId) {
+      throw new Error("No active transaction");
+    }
+    const transactionId = activeTransactionId;
+    const deviceIdForRollback = activeDeviceId;
+    setTransactionState("rolling_back");
+    const promise = waitForTransaction(transactionId, "rollback");
+    send({
+      type: MessageType.ROLLBACK_TRANSACTION_REQUEST,
+      transactionId,
+      deviceId: deviceIdForRollback
+    });
+    await promise;
+  };
+  const executeWrite = async (operation) => {
+    if (role !== DevToolsRole.BROWSER) {
+      throw new Error("executeWrite is only available for browser clients");
+    }
+    if (!activeTransactionId || !activeDeviceId || transactionState !== "open") {
+      throw new Error("No open transaction");
+    }
+    const writeId = generateWriteId();
+    const promise = new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        pendingWrites.delete(writeId);
+        reject(new Error("Write operation timed out"));
+      }, WRITE_TIMEOUT_MS);
+      pendingWrites.set(writeId, {
+        resolve: (result) => {
+          clearTimeout(timer);
+          resolve(result);
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        }
+      });
+    });
+    send({
+      type: MessageType.WRITE_REQUEST,
+      writeId,
+      transactionId: activeTransactionId,
+      deviceId: activeDeviceId,
+      operation
+    });
+    return promise;
+  };
+  return {
+    connect,
+    disconnect,
+    getConnectionState: () => connectionState,
+    getLastConnectionError: () => lastConnectionError,
+    getDeviceStatus: () => deviceStatus,
+    getDeviceId: () => deviceId,
+    getServerUrl: () => wsUrl,
+    setServerUrl,
+    send,
+    requestRefresh,
+    requestExportSnapshot,
+    sendTransactionAck,
+    sendWriteAck,
+    beginTransaction,
+    commitTransaction,
+    rollbackTransaction,
+    executeWrite,
+    getTransactionState: () => transactionState,
+    getActiveTransactionId: () => activeTransactionId
+  };
+}
+
+// src/client/fetchSnapshot.ts
+async function fetchSnapshot(downloadUrl) {
+  let response;
+  try {
+    response = await fetch(downloadUrl);
+  } catch (error) {
+    const networkMessage = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `Network error fetching snapshot from ${downloadUrl}. ${networkMessage} If the web UI runs on a different port than the hub, ensure CORS is enabled on the hub HTTP API.`
+    );
+  }
+  if (!response.ok) {
+    throw new Error(
+      `Failed to fetch snapshot from ${downloadUrl}: ${response.status} ${response.statusText}`
+    );
+  }
+  return response.arrayBuffer();
+}
+
+// src/client/snapshotUpload.ts
+function createSnapshotUploadBody(bytes) {
+  return bytes;
+}
+async function uploadSnapshot(uploadUrl, bytes, options) {
+  const headers = {
+    "Content-Type": "application/octet-stream",
+    [options.kindHeader]: options.kind,
+    [options.mimeHeader]: options.mimeType
+  };
+  if (options.databaseName && options.nameHeader) {
+    headers[options.nameHeader] = options.databaseName;
+  }
+  const response = await fetch(uploadUrl, {
+    method: "POST",
+    headers,
+    body: createSnapshotUploadBody(bytes)
+  });
+  if (!response.ok) {
+    throw new Error(`Upload failed with status ${response.status}`);
+  }
+}
+
+// src/client/handleDeviceSnapshot.ts
+async function handleDeviceSnapshotUpload(database, message, options = {}) {
+  if (options.deviceId && message.deviceId !== options.deviceId) {
+    return;
+  }
+  if (!database) {
+    throw new Error("No database adapter configured");
+  }
+  if (!options.hubServerUrl) {
+    throw new Error("hubServerUrl is required to upload a device snapshot");
+  }
+  const snapshot = await database.exportSnapshot();
+  const hubHttp = wsUrlToHttpUrl(options.hubServerUrl);
+  const uploadUrl = buildDeviceSnapshotUrl(hubHttp, message.deviceId);
+  await uploadSnapshot(uploadUrl, snapshot.bytes, {
+    kind: snapshot.kind,
+    mimeType: snapshot.mimeType,
+    kindHeader: SNAPSHOT_KIND_HEADER,
+    mimeHeader: SNAPSHOT_MIME_HEADER,
+    databaseName: database.name,
+    nameHeader: SNAPSHOT_NAME_HEADER
+  });
+}
+
+// src/utils/isDevToolsEnabled.ts
+function isDevToolsEnabled(enabled) {
+  if (enabled === false) {
+    return false;
+  }
+  if (enabled === true) {
+    return true;
+  }
+  return typeof __DEV__ !== "undefined" && __DEV__;
+}
+
+// src/client/formatSyncError.ts
+function formatRefreshErrorMessage(code, message) {
+  switch (code) {
+    case "DEVICE_OFFLINE":
+      return "Selected device disconnected. Reconnect the mobile app and try again.";
+    case "REFRESH_IN_PROGRESS":
+      return "A refresh is already in progress for this device.";
+    case "EXPORT_FAILED":
+      return `Device failed to export or upload snapshot: ${message}`;
+    case "UPLOAD_FAILED":
+      return `Snapshot upload failed on the hub: ${message}`;
+    case "TIMEOUT":
+      return "Timed out waiting for the device to upload a snapshot.";
+    case "SNAPSHOT_NOT_FOUND":
+      return "Snapshot expired or was not found. Click Refresh again.";
+    case "INVALID_REQUEST":
+      return `Invalid refresh request: ${message}`;
+    default:
+      return message;
+  }
+}
+
+// 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"
+    });
+  }
+}
+var DevToolsContext = react.createContext(null);
+function useDevTools() {
+  const context = react.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: reactNative.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;
+}
+
+// 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 quoteIdentifier2(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(${quoteIdentifier2(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 ${quoteIdentifier2(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(${quoteIdentifier2(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 = quoteIdentifier2(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 ${quoteIdentifier2(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
+      };
+    })
+  };
+}
+function DevToolsProvider({
+  children,
+  database,
+  type,
+  adapter: explicitAdapter,
+  serverUrl: initialServerUrl,
+  onConnectionStateChange
+}) {
+  const [connectionState, setConnectionState] = react.useState("connecting");
+  const [connectionError, setConnectionError] = react.useState(null);
+  const [serverUrl, setServerUrl] = react.useState(() => resolveServerUrl(initialServerUrl));
+  const [deviceId, setDeviceId] = react.useState();
+  const [deviceIdReady, setDeviceIdReady] = react.useState(false);
+  const [settingsVisible, setSettingsVisible] = react.useState(false);
+  const [launcherVisible, setLauncherVisible] = react.useState(false);
+  const [explorerVisible, setExplorerVisible] = react.useState(false);
+  const [mobileInspector, setMobileInspector] = react.useState(null);
+  const [resolvedAdapter, setResolvedAdapter] = react.useState(explicitAdapter);
+  const [adapterError, setAdapterError] = react.useState(null);
+  const [exportState, setExportState] = react.useState("idle");
+  const [exportError, setExportError] = react.useState(null);
+  const metadata = react.useMemo(() => resolveDeviceMetadata(), []);
+  const clientRef = react.useRef(null);
+  const onConnectionStateChangeRef = react.useRef(onConnectionStateChange);
+  const databaseRef = react.useRef(resolvedAdapter);
+  const rollbackOpenTransactionRef = react.useRef(null);
+  const exportWaitersRef = react.useRef(null);
+  const exportTimeoutRef = react.useRef(null);
+  const exportSuccessTimeoutRef = react.useRef(null);
+  const clearExportWaiters = react.useCallback(() => {
+    if (exportTimeoutRef.current) {
+      clearTimeout(exportTimeoutRef.current);
+      exportTimeoutRef.current = null;
+    }
+    exportWaitersRef.current = null;
+  }, []);
+  const resetExportSuccessLater = react.useCallback(() => {
+    if (exportSuccessTimeoutRef.current) {
+      clearTimeout(exportSuccessTimeoutRef.current);
+    }
+    exportSuccessTimeoutRef.current = setTimeout(() => {
+      setExportState((current) => current === "success" ? "idle" : current);
+      exportSuccessTimeoutRef.current = null;
+    }, 3e3);
+  }, []);
+  const finishExportSuccess = react.useCallback(() => {
+    clearExportWaiters();
+    setExportState("success");
+    setExportError(null);
+    resetExportSuccessLater();
+  }, [clearExportWaiters, resetExportSuccessLater]);
+  const finishExportFailure = react.useCallback(
+    (message) => {
+      clearExportWaiters();
+      setExportState("error");
+      setExportError(message);
+    },
+    [clearExportWaiters]
+  );
+  react.useEffect(() => {
+    onConnectionStateChangeRef.current = onConnectionStateChange;
+  }, [onConnectionStateChange]);
+  react.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]);
+  react.useEffect(() => {
+    if (detectExpoSqliteInspectable(database)) {
+      setMobileInspector(createExpoSqliteInspector(database));
+      return;
+    }
+    setMobileInspector(null);
+  }, [database]);
+  react.useEffect(() => {
+    databaseRef.current = resolvedAdapter;
+  }, [resolvedAdapter]);
+  react.useEffect(() => {
+    rollbackOpenTransactionRef.current = async () => {
+      const adapter = databaseRef.current;
+      if (!isWritableDatabaseAdapter(adapter)) {
+        return;
+      }
+      try {
+        await adapter.rollbackTransaction();
+      } catch {
+      }
+    };
+  }, [resolvedAdapter]);
+  react.useEffect(() => {
+    let cancelled = false;
+    void loadOrCreateDeviceId().then((persistedId) => {
+      if (!cancelled) {
+        setDeviceId(persistedId);
+        setDeviceIdReady(true);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, []);
+  react.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 = react.useCallback(() => {
+    setLauncherVisible(true);
+  }, []);
+  const closeLauncher = react.useCallback(() => {
+    setLauncherVisible(false);
+  }, []);
+  const openExplorer = react.useCallback(() => {
+    setLauncherVisible(false);
+    setExplorerVisible(true);
+  }, []);
+  const closeExplorer = react.useCallback(() => {
+    setExplorerVisible(false);
+  }, []);
+  const openSettings = react.useCallback(() => {
+    setLauncherVisible(false);
+    setSettingsVisible(true);
+  }, []);
+  const closeSettings = react.useCallback(() => {
+    setSettingsVisible(false);
+  }, []);
+  const reconnect = react.useCallback((url) => {
+    setConnectionError(null);
+    setServerUrl(normalizeServerUrl(url));
+  }, []);
+  const exportDatabase = react.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 = react.useMemo(() => getConnectionHint(serverUrl), [serverUrl]);
+  const value = react.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__ */ jsxRuntime.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__ */ jsxRuntime.jsxs(reactNative.View, { style: [styles.badge, { backgroundColor: config.backgroundColor }], children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [styles.dot, { backgroundColor: getConnectionDotColor(state) }] }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles.label, { color: config.color }], children: config.label })
+  ] });
+}
+var styles = reactNative.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__ */ jsxRuntime.jsx(
+    reactNative.Modal,
+    {
+      animationType: "slide",
+      onRequestClose: closeLauncher,
+      transparent: true,
+      visible: launcherVisible,
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles2.overlay, children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles2.sheet, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles2.header, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.title, children: "Database DevTools" }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { accessibilityLabel: "Close launcher", onPress: closeLauncher, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.closeButton, children: "Close" }) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles2.body, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(ConnectionStatusBadge, { state: connectionState }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.hint, children: "Browse and query the on-device database, or connect to the web inspector." }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.Pressable,
+            {
+              accessibilityLabel: "View database on device",
+              disabled: !mobileInspector,
+              onPress: openExplorer,
+              style: [styles2.primaryButton, !mobileInspector && styles2.primaryButtonDisabled],
+              children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.primaryLabel, children: "View Database" })
+            }
+          ),
+          !mobileInspector ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.warning, children: "On-device explorer requires an Expo SQLite database instance." }) : null,
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.Pressable,
+            {
+              accessibilityLabel: "Open DevTools settings",
+              onPress: openSettings,
+              style: styles2.secondaryButton,
+              children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.secondaryLabel, children: "DevTools Settings" })
+            }
+          ),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.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__ */ jsxRuntime.jsxs(reactNative.View, { style: styles2.exportContent, children: [
+                isExporting ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.ActivityIndicator, { color: "#0f172a", size: "small" }) : null,
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.ghostLabel, children: isExporting ? "Exporting\u2026" : "Export to Web Inspector" })
+              ] })
+            }
+          ),
+          connectionState !== "connected" ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.hint, children: "Connect to the hub in settings before exporting." }) : null,
+          exportState === "success" ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.success, children: "Sent to web inspector" }) : null,
+          exportError ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.error, children: exportError }) : null,
+          adapterError ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles2.error, children: adapterError }) : null
+        ] })
+      ] }) })
+    }
+  );
+}
+var styles2 = reactNative.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: reactNative.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] = react.useState(serverUrl);
+  react.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__ */ jsxRuntime.jsx(
+    reactNative.Modal,
+    {
+      animationType: "slide",
+      onRequestClose: closeSettings,
+      transparent: true,
+      visible: settingsVisible,
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: styles3.overlay, children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles3.sheet, children: [
+        /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles3.header, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.title, children: "Database DevTools" }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { accessibilityLabel: "Close settings", onPress: closeSettings, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.closeButton, children: "Close" }) })
+        ] }),
+        /* @__PURE__ */ jsxRuntime.jsxs(
+          reactNative.ScrollView,
+          {
+            contentContainerStyle: styles3.content,
+            style: styles3.scrollBody,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsxs(Section, { title: "Connection", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(ConnectionStatusBadge, { state: connectionState }),
+                /* @__PURE__ */ jsxRuntime.jsx(InfoRow, { label: "Server URL", value: serverUrl, mono: true }),
+                connectionError ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.errorText, children: connectionError }) : null,
+                connectionHint ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.hintText, children: connectionHint }) : null,
+                connectionState === "reconnecting" ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.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__ */ jsxRuntime.jsxs(Section, { title: "Device", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(InfoRow, { label: "Device ID", value: deviceId ?? "\u2014", mono: true }),
+                /* @__PURE__ */ jsxRuntime.jsx(InfoRow, { label: "Platform", value: metadata.platform ?? "\u2014" }),
+                /* @__PURE__ */ jsxRuntime.jsx(InfoRow, { label: "App", value: metadata.appName ?? "\u2014" }),
+                metadata.appVersion ? /* @__PURE__ */ jsxRuntime.jsx(InfoRow, { label: "Version", value: metadata.appVersion }) : null,
+                metadata.bundleId ? /* @__PURE__ */ jsxRuntime.jsx(InfoRow, { label: "Bundle ID", value: metadata.bundleId, mono: true }) : null
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsxs(Section, { title: "Server", children: [
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.fieldLabel, children: "WebSocket URL" }),
+                /* @__PURE__ */ jsxRuntime.jsx(
+                  reactNative.TextInput,
+                  {
+                    autoCapitalize: "none",
+                    autoCorrect: false,
+                    onChangeText: setDraftUrl,
+                    placeholder: "ws://10.0.2.2:3847/ws",
+                    style: styles3.input,
+                    value: draftUrl
+                  }
+                ),
+                /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onPress: handleReconnect, style: styles3.reconnectButton, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.reconnectLabel, children: "Reconnect" }) })
+              ] }),
+              /* @__PURE__ */ jsxRuntime.jsx(Section, { title: "Database", children: database ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+                /* @__PURE__ */ jsxRuntime.jsx(InfoRow, { label: "Kind", value: database.kind }),
+                /* @__PURE__ */ jsxRuntime.jsx(InfoRow, { label: "Name", value: database.name }),
+                /* @__PURE__ */ jsxRuntime.jsx(InfoRow, { label: "ID", value: database.id, mono: true })
+              ] }) : /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.placeholder, children: adapterError ? "Adapter not connected" : "No adapter connected" }) })
+            ]
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles3.exportFooter, children: [
+          adapterError ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.errorText, children: adapterError }) : null,
+          database ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(
+              reactNative.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__ */ jsxRuntime.jsxs(reactNative.View, { style: styles3.exportButtonContent, children: [
+                  isExporting ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.ActivityIndicator, { color: "#f8fafc", size: "small" }) : null,
+                  /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.exportLabel, children: isExporting ? "Exporting\u2026" : "Export Database" })
+                ] })
+              }
+            ),
+            connectionState !== "connected" ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.hintText, children: "Connect to the hub before exporting." }) : null,
+            exportState === "success" ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.successText, children: "Sent to web inspector" }) : null,
+            exportError ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.errorText, children: exportError }) : null
+          ] }) : /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.placeholder, children: adapterError ? "Adapter not connected" : "No adapter connected" })
+        ] })
+      ] }) })
+    }
+  );
+}
+function Section({ title, children }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles3.section, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.sectionTitle, children: title }),
+    children
+  ] });
+}
+function InfoRow({
+  label,
+  value,
+  mono = false
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: styles3.infoRow, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: styles3.infoLabel, children: label }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [styles3.infoValue, mono && styles3.mono], selectable: true, children: value })
+  ] });
+}
+var styles3 = reactNative.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: reactNative.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: reactNative.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 } = reactNative.useWindowDimensions();
+  const [internalPosition, setInternalPosition] = react.useState(null);
+  const [dragPosition, setDragPosition] = react.useState(null);
+  const dragOrigin = react.useRef({ x: 0, y: 0 });
+  const hasInitialized = react.useRef(false);
+  const onFloatingPositionChangeRef = react.useRef(onFloatingPositionChange);
+  react.useEffect(() => {
+    onFloatingPositionChangeRef.current = onFloatingPositionChange;
+  }, [onFloatingPositionChange]);
+  const layout = react.useMemo(
+    () => ({
+      windowWidth,
+      windowHeight,
+      buttonSize: FLOATING_BUTTON_SIZE,
+      margin: FLOATING_BUTTON_MARGIN
+    }),
+    [windowWidth, windowHeight]
+  );
+  const committedPosition = floatingPosition ?? internalPosition;
+  const renderedPosition = dragPosition ?? committedPosition;
+  const commitPosition = react.useCallback(
+    (next) => {
+      const clamped = clampFloatingPosition(next, layout);
+      if (!floatingPosition) {
+        setInternalPosition(clamped);
+      }
+      onFloatingPositionChangeRef.current?.(clamped);
+      return clamped;
+    },
+    [floatingPosition, layout]
+  );
+  react.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]);
+  react.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 = react.useMemo(
+    () => reactNative.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__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      MaterialCommunityIcons__default.default,
+      {
+        color: DEFAULT_ICON_COLOR,
+        name: "database",
+        size: DEFAULT_ICON_SIZE,
+        style: iconStyle
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.View,
+      {
+        style: [styles4.statusDot, { backgroundColor: getConnectionDotColor(connectionState) }]
+      }
+    )
+  ] });
+  if (!draggable) {
+    const positionStyle = position === "bottom-left" ? styles4.bottomLeft : styles4.bottomRight;
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: [styles4.fixedContainer, positionStyle], pointerEvents: "box-none", children: /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Pressable,
+      {
+        accessibilityLabel: "Open Database DevTools",
+        accessibilityRole: "button",
+        onPress: openLauncher,
+        style: ({ pressed }) => [styles4.button, pressed && styles4.buttonPressed],
+        children: buttonContent
+      }
+    ) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      pointerEvents: "box-none",
+      style: [
+        styles4.draggableContainer,
+        {
+          transform: [
+            { translateX: renderedPosition.x },
+            { translateY: renderedPosition.y }
+          ]
+        }
+      ],
+      ...panResponder.panHandlers,
+      children: /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.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 = reactNative.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 = reactNative.StyleSheet.create({
+  fullScreen: {
+    flex: 1,
+    backgroundColor: explorerColors.background
+  },
+  header: {
+    flexDirection: "row",
+    alignItems: "center",
+    justifyContent: "space-between",
+    paddingHorizontal: 16,
+    paddingVertical: 14,
+    borderBottomWidth: reactNative.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: reactNative.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: reactNative.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: reactNative.StyleSheet.hairlineWidth,
+    borderTopColor: explorerColors.border
+  },
+  paginationLabel: {
+    fontSize: 12,
+    color: explorerColors.muted
+  }
+});
+var tableStyles = reactNative.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: reactNative.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__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.placeholder, children: "Loading database info\u2026" });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.errorText, children: error });
+  }
+  if (!info) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.placeholder, children: "No database information available." });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.ScrollView, { contentContainerStyle: explorerStyles.content, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.sectionTitle, children: "Database" }),
+    /* @__PURE__ */ jsxRuntime.jsx(Info, { label: "Name", value: info.name }),
+    /* @__PURE__ */ jsxRuntime.jsx(Info, { label: "Path", value: info.path, mono: true }),
+    /* @__PURE__ */ jsxRuntime.jsx(Info, { label: "SQLite version", value: info.sqliteVersion }),
+    /* @__PURE__ */ jsxRuntime.jsx(Info, { label: "Tables", value: String(info.tableCount) }),
+    /* @__PURE__ */ jsxRuntime.jsx(Info, { label: "Estimated size", value: formatBytes(info.estimatedSizeBytes) }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      Info,
+      {
+        label: "Pages",
+        value: `${info.pageCount.toLocaleString()} \xD7 ${info.pageSize} bytes`
+      }
+    ),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { height: 16 } }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.sectionTitle, children: "Quick actions" }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: { gap: 8 }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(ActionButton, { label: "Browse tables", onPress: onOpenTables }),
+      /* @__PURE__ */ jsxRuntime.jsx(ActionButton, { label: "Run SQL query", onPress: onOpenSql })
+    ] })
+  ] });
+}
+function Info({ label, value, mono = false }) {
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: explorerStyles.infoRow, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.infoLabel, children: label }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [explorerStyles.infoValue, mono && explorerStyles.mono], selectable: true, children: value })
+  ] });
+}
+function ActionButton({ label, onPress }) {
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onPress, style: explorerStyles.ghostButton, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.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] = react.useState(null);
+  const copyValue = async (value, key) => {
+    await copyToClipboard();
+    setCopiedKey(key);
+    setTimeout(() => setCopiedKey(null), 1500);
+  };
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.FlatList,
+    {
+      data: rows,
+      keyExtractor: (_, index) => String(index),
+      contentContainerStyle: tableStyles.cardList,
+      style: tableStyles.bodyList,
+      renderItem: ({ item: row, index: rowIndex }) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.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__ */ jsxRuntime.jsxs(
+          reactNative.Pressable,
+          {
+            onPress: () => void copyValue(value, key),
+            style: tableStyles.cardField,
+            children: [
+              /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: tableStyles.cardLabel, children: column }),
+              /* @__PURE__ */ jsxRuntime.jsx(
+                reactNative.Text,
+                {
+                  style: [
+                    tableStyles.cardValue,
+                    isMonospaceColumn(column) && tableStyles.cardValueMono,
+                    isNull && tableStyles.cellNull
+                  ],
+                  children: value
+                }
+              ),
+              copiedKey === key && /* @__PURE__ */ jsxRuntime.jsx(reactNative.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 } = reactNative.useWindowDimensions();
+  const [copiedKey, setCopiedKey] = react.useState(null);
+  const columnWidths = react.useMemo(
+    () => columnWidthsProp ?? computeColumnWidths(columns, rows),
+    [columnWidthsProp, columns, rows]
+  );
+  const tableWidth = react.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__ */ jsxRuntime.jsx(reactNative.View, { style: tableStyles.headerRow, children: columns.map((column, index) => /* @__PURE__ */ jsxRuntime.jsx(
+    reactNative.View,
+    {
+      style: [tableStyles.cell, tableStyles.headerCell, { width: columnWidths[index] }],
+      children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: tableStyles.headerText, children: column })
+    },
+    column
+  )) });
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: tableStyles.tableContainer, children: [
+    showScrollHint && /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: tableStyles.scrollHint, children: "Swipe horizontally for more columns" }),
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.ScrollView,
+      {
+        horizontal: true,
+        bounces: false,
+        nestedScrollEnabled: true,
+        showsHorizontalScrollIndicator: true,
+        style: tableStyles.horizontalScroll,
+        children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: { width: tableWidth, flex: 1 }, children: [
+          headerRow,
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.FlatList,
+            {
+              data: rows,
+              keyExtractor: (_, index) => String(index),
+              nestedScrollEnabled: true,
+              style: tableStyles.bodyList,
+              renderItem: ({ item: row, index: rowIndex }) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.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__ */ jsxRuntime.jsxs(
+                  reactNative.Pressable,
+                  {
+                    onPress: () => void copyCell(display, key),
+                    style: [tableStyles.cell, { width: columnWidths[cellIndex] }],
+                    children: [
+                      /* @__PURE__ */ jsxRuntime.jsx(
+                        reactNative.Text,
+                        {
+                          numberOfLines: 2,
+                          selectable: true,
+                          style: [
+                            tableStyles.cellText,
+                            isMonospaceColumn(column) && tableStyles.cellTextMono,
+                            isNull && tableStyles.cellNull
+                          ],
+                          children: display
+                        }
+                      ),
+                      copiedKey === key && /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: tableStyles.copiedHint, children: "Copied" })
+                    ]
+                  },
+                  key
+                );
+              }) })
+            }
+          )
+        ] })
+      }
+    )
+  ] });
+}
+function MobileDataView({
+  columns,
+  rows,
+  metaSuffix,
+  defaultMode = "table",
+  dataKey
+}) {
+  const [mode, setMode] = react.useState(defaultMode);
+  const columnWidths = react.useMemo(() => computeColumnWidths(columns, rows), [columns, rows]);
+  const tableWidth = react.useMemo(() => totalTableWidth(columnWidths), [columnWidths]);
+  const columnsKey = columns.join("|");
+  react.useEffect(() => {
+    setMode(defaultMode);
+  }, [columnsKey, dataKey, defaultMode, rows.length]);
+  if (columns.length === 0) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.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__ */ jsxRuntime.jsxs(reactNative.View, { style: tableStyles.viewRoot, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: tableStyles.viewToolbar, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: tableStyles.viewMeta, children: meta }),
+      /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: tableStyles.viewToggle, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Pressable,
+          {
+            onPress: () => setMode("cards"),
+            style: [tableStyles.viewToggleButton, mode === "cards" && tableStyles.viewToggleButtonActive],
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              reactNative.Text,
+              {
+                style: [tableStyles.viewToggleLabel, mode === "cards" && tableStyles.viewToggleLabelActive],
+                children: "Cards"
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Pressable,
+          {
+            onPress: () => setMode("table"),
+            style: [tableStyles.viewToggleButton, mode === "table" && tableStyles.viewToggleButtonActive],
+            children: /* @__PURE__ */ jsxRuntime.jsx(
+              reactNative.Text,
+              {
+                style: [tableStyles.viewToggleLabel, mode === "table" && tableStyles.viewToggleLabelActive],
+                children: "Table"
+              }
+            )
+          }
+        )
+      ] })
+    ] }),
+    mode === "cards" ? /* @__PURE__ */ jsxRuntime.jsx(MobileDataCardList, { columns, rows }) : /* @__PURE__ */ jsxRuntime.jsx(MobileDataTable, { columnWidths, columns, rows }),
+    mode === "table" && tableWidth > 320 && /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: tableStyles.footerHint, children: "Tap a cell to copy its value" }),
+    mode === "cards" && /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: tableStyles.footerHint, children: "Tap a field to copy its value" })
+  ] });
+}
+function ExplorerSqlTab({ inspector }) {
+  const [sql, setSql] = react.useState(DEFAULT_MOBILE_SQL);
+  const [result, setResult] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  const [running, setRunning] = react.useState(false);
+  const [panel, setPanel] = react.useState("results");
+  const [resultKey, setResultKey] = react.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__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.errorText, children: error });
+      }
+      if (result) {
+        return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Text, { style: explorerStyles.infoValue, children: [
+          "Query executed successfully. ",
+          result.rowCount,
+          " row",
+          result.rowCount === 1 ? "" : "s",
+          " in ",
+          result.durationMs.toFixed(1),
+          " ms."
+        ] });
+      }
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.placeholder, children: "Messages and errors appear here." });
+    }
+    if (!result) {
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: explorerStyles.sqlResultsEmpty, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [explorerStyles.placeholder, { marginTop: 0 }], children: "Run a query to see results." }) });
+    }
+    if (result.columns.length === 0) {
+      return /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: explorerStyles.sqlResultsEmpty, children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Text, { style: [explorerStyles.placeholder, { marginTop: 0 }], children: [
+        "Query completed with no result set (",
+        result.durationMs.toFixed(1),
+        " ms)."
+      ] }) });
+    }
+    return /* @__PURE__ */ jsxRuntime.jsx(
+      MobileDataView,
+      {
+        columns: result.columns,
+        dataKey: String(resultKey),
+        defaultMode: "table",
+        metaSuffix: `${result.durationMs.toFixed(1)} ms`,
+        rows: result.rows
+      }
+    );
+  };
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: explorerStyles.sqlTabRoot, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: explorerStyles.sqlQueryPane, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.sectionTitle, children: "SQL (read-only)" }),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.TextInput,
+        {
+          autoCapitalize: "none",
+          autoCorrect: false,
+          multiline: true,
+          onChangeText: setSql,
+          scrollEnabled: true,
+          style: explorerStyles.sqlInputCompact,
+          value: sql
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Pressable,
+        {
+          disabled: running,
+          onPress: () => void runQuery(),
+          style: [explorerStyles.primaryButton, running && explorerStyles.primaryButtonDisabled],
+          children: running ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.ActivityIndicator, { color: "#f8fafc" }) : /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.primaryButtonLabel, children: "Run query" })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [explorerStyles.hintText, { marginTop: 0 }], children: "Allowed: SELECT, PRAGMA, EXPLAIN, WITH. Writes are blocked in DevTools." })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [explorerStyles.tabRow, { flexShrink: 0 }], children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Pressable,
+        {
+          onPress: () => setPanel("results"),
+          style: [explorerStyles.tab, panel === "results" && explorerStyles.tabActive],
+          children: /* @__PURE__ */ jsxRuntime.jsxs(
+            reactNative.Text,
+            {
+              style: [explorerStyles.tabLabel, panel === "results" && explorerStyles.tabLabelActive],
+              children: [
+                "Results",
+                result ? ` (${result.rowCount})` : ""
+              ]
+            }
+          )
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Pressable,
+        {
+          onPress: () => setPanel("output"),
+          style: [explorerStyles.tab, panel === "output" && explorerStyles.tabActive],
+          children: /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.Text,
+            {
+              style: [explorerStyles.tabLabel, panel === "output" && explorerStyles.tabLabelActive],
+              children: "Output"
+            }
+          )
+        }
+      )
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: explorerStyles.sqlResultsPane, children: renderResultsContent() })
+  ] });
+}
+function ExplorerTableDetail({ inspector, tableName, onBack }) {
+  const [view, setView] = react.useState("data");
+  const [columns, setColumns] = react.useState([]);
+  const [pageResult, setPageResult] = react.useState(null);
+  const [search, setSearch] = react.useState("");
+  const [page, setPage] = react.useState(1);
+  const [loading, setLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const loadData = react.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]);
+  react.useEffect(() => {
+    void loadData();
+  }, [loadData]);
+  const totalPages = pageResult ? Math.max(1, Math.ceil(pageResult.totalCount / pageResult.pageSize)) : 1;
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: explorerStyles.fullScreen, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: explorerStyles.header, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { onPress: onBack, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.headerAction, children: "\u2190 Back" }) }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.headerTitle, children: tableName }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: { width: 48 } })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: [explorerStyles.subTabRow, { paddingHorizontal: 16, paddingTop: 12 }], children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Pressable,
+        {
+          onPress: () => setView("data"),
+          style: [explorerStyles.subTab, view === "data" && explorerStyles.subTabActive],
+          children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: [explorerStyles.subTabLabel, view === "data" && explorerStyles.subTabLabelActive], children: "Data" })
+        }
+      ),
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.Pressable,
+        {
+          onPress: () => setView("schema"),
+          style: [explorerStyles.subTab, view === "schema" && explorerStyles.subTabActive],
+          children: /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.Text,
+            {
+              style: [explorerStyles.subTabLabel, view === "schema" && explorerStyles.subTabLabelActive],
+              children: "Schema"
+            }
+          )
+        }
+      )
+    ] }),
+    view === "data" ? /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: tableStyles.detailBody, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(
+        reactNative.TextInput,
+        {
+          autoCapitalize: "none",
+          autoCorrect: false,
+          onChangeText: (value) => {
+            setSearch(value);
+            setPage(1);
+          },
+          placeholder: "Search rows\u2026",
+          style: explorerStyles.searchInput,
+          value: search
+        }
+      ),
+      loading ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.ActivityIndicator, { style: { marginTop: 24 } }) : error ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.errorText, children: error }) : pageResult ? /* @__PURE__ */ jsxRuntime.jsxs(jsxRuntime.Fragment, { children: [
+        /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: tableStyles.detailDataPane, children: /* @__PURE__ */ jsxRuntime.jsx(
+          MobileDataView,
+          {
+            columns: pageResult.columns,
+            dataKey: `${tableName}-${page}-${search}`,
+            defaultMode: "table",
+            metaSuffix: `page ${page} of ${totalPages}`,
+            rows: pageResult.rows
+          }
+        ) }),
+        /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: explorerStyles.paginationRow, children: [
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { disabled: page <= 1, onPress: () => setPage((current) => current - 1), children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.headerAction, children: "Previous" }) }),
+          /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Text, { style: explorerStyles.paginationLabel, children: [
+            "Page ",
+            page,
+            " of ",
+            totalPages,
+            " \xB7 ",
+            pageResult.totalCount.toLocaleString(),
+            " rows"
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx(
+            reactNative.Pressable,
+            {
+              disabled: page >= totalPages,
+              onPress: () => setPage((current) => current + 1),
+              children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.headerAction, children: "Next" })
+            }
+          )
+        ] })
+      ] }) : null
+    ] }) : /* @__PURE__ */ jsxRuntime.jsx(reactNative.ScrollView, { contentContainerStyle: explorerStyles.content, children: columns.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.placeholder, children: "No schema information." }) : columns.map((column) => /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: explorerStyles.listItem, children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: { flex: 1 }, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.listItemTitle, children: column.name }),
+      /* @__PURE__ */ jsxRuntime.jsxs(reactNative.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] = react.useState("");
+  const filtered = react.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__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.placeholder, children: "Loading tables\u2026" });
+  }
+  if (error) {
+    return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.errorText, children: error });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: { flex: 1, padding: 16 }, children: [
+    /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.TextInput,
+      {
+        autoCapitalize: "none",
+        autoCorrect: false,
+        onChangeText: setSearch,
+        placeholder: "Filter tables\u2026",
+        style: explorerStyles.searchInput,
+        value: search
+      }
+    ),
+    filtered.length === 0 ? /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.placeholder, children: "No tables match your search." }) : /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.FlatList,
+      {
+        data: filtered,
+        keyExtractor: (item) => item.name,
+        style: { flex: 1 },
+        renderItem: ({ item }) => /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Pressable, { onPress: () => onSelectTable(item.name), style: explorerStyles.listItem, children: [
+          /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { children: [
+            /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.listItemTitle, children: item.name }),
+            /* @__PURE__ */ jsxRuntime.jsxs(reactNative.Text, { style: explorerStyles.listItemMeta, children: [
+              item.rowCount.toLocaleString(),
+              " row",
+              item.rowCount === 1 ? "" : "s"
+            ] })
+          ] }),
+          /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.listItemMeta, children: "\u203A" })
+        ] })
+      }
+    )
+  ] });
+}
+function MobileDatabaseExplorer() {
+  const { explorerVisible, closeExplorer, mobileInspector } = useDevTools();
+  const [tab, setTab] = react.useState("overview");
+  const [screen, setScreen] = react.useState({ kind: "tabs" });
+  const [info, setInfo] = react.useState(null);
+  const [tables, setTables] = react.useState([]);
+  const [loading, setLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const loadOverview = react.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]);
+  react.useEffect(() => {
+    if (!explorerVisible) {
+      setScreen({ kind: "tabs" });
+      setTab("overview");
+      return;
+    }
+    void loadOverview();
+  }, [explorerVisible, loadOverview]);
+  if (!mobileInspector) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx(reactNative.Modal, { animationType: "slide", onRequestClose: closeExplorer, visible: explorerVisible, children: screen.kind === "table" ? /* @__PURE__ */ jsxRuntime.jsx(
+    ExplorerTableDetail,
+    {
+      inspector: mobileInspector,
+      onBack: () => setScreen({ kind: "tabs" }),
+      tableName: screen.tableName
+    }
+  ) : /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: explorerStyles.fullScreen, children: [
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: explorerStyles.header, children: [
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.headerTitle, children: "Database Explorer" }),
+      /* @__PURE__ */ jsxRuntime.jsx(reactNative.Pressable, { accessibilityLabel: "Close database explorer", onPress: closeExplorer, children: /* @__PURE__ */ jsxRuntime.jsx(reactNative.Text, { style: explorerStyles.headerAction, children: "Close" }) })
+    ] }),
+    /* @__PURE__ */ jsxRuntime.jsx(reactNative.View, { style: explorerStyles.tabRow, children: ["overview", "tables", "sql"].map((item) => /* @__PURE__ */ jsxRuntime.jsx(
+      reactNative.Pressable,
+      {
+        onPress: () => setTab(item),
+        style: [explorerStyles.tab, tab === item && explorerStyles.tabActive],
+        children: /* @__PURE__ */ jsxRuntime.jsx(
+          reactNative.Text,
+          {
+            style: [explorerStyles.tabLabel, tab === item && explorerStyles.tabLabelActive],
+            children: item === "overview" ? "Overview" : item === "tables" ? "Tables" : "SQL"
+          }
+        )
+      },
+      item
+    )) }),
+    /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { style: { flex: 1 }, children: [
+      tab === "overview" && /* @__PURE__ */ jsxRuntime.jsx(
+        ExplorerOverviewTab,
+        {
+          error,
+          info,
+          loading,
+          onOpenSql: () => setTab("sql"),
+          onOpenTables: () => setTab("tables")
+        }
+      ),
+      tab === "tables" && /* @__PURE__ */ jsxRuntime.jsx(
+        ExplorerTablesTab,
+        {
+          error,
+          loading,
+          onSelectTable: (tableName) => setScreen({ kind: "table", tableName }),
+          tables
+        }
+      ),
+      tab === "sql" && /* @__PURE__ */ jsxRuntime.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__ */ jsxRuntime.jsx(
+    DevToolsProvider,
+    {
+      adapter,
+      database,
+      onConnectionStateChange,
+      serverUrl,
+      type,
+      children: /* @__PURE__ */ jsxRuntime.jsxs(reactNative.View, { pointerEvents: "box-none", style: reactNative.StyleSheet.absoluteFill, children: [
+        /* @__PURE__ */ jsxRuntime.jsx(
+          FloatingDevToolsButton,
+          {
+            draggable,
+            floatingPosition,
+            iconStyle: style,
+            onFloatingPositionChange,
+            position,
+            snapToEdges
+          }
+        ),
+        /* @__PURE__ */ jsxRuntime.jsx(DevToolsLauncherModal, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(DevToolsSettingsModal, {}),
+        /* @__PURE__ */ jsxRuntime.jsx(MobileDatabaseExplorer, {})
+      ] })
+    }
+  );
+}
+
+exports.AdapterResolutionError = AdapterResolutionError;
+exports.DATABASE_DEVTOOLS_KIND = DATABASE_DEVTOOLS_KIND;
+exports.DEFAULT_DEVTOOLS_HOST = DEFAULT_DEVTOOLS_HOST;
+exports.DEFAULT_DEVTOOLS_PORT = DEFAULT_DEVTOOLS_PORT;
+exports.DEVICE_SNAPSHOT_API_PATH = DEVICE_SNAPSHOT_API_PATH;
+exports.DEVTOOLS_WS_PATH = DEVTOOLS_WS_PATH;
+exports.DatabaseDevTools = DatabaseDevTools;
+exports.DevToolsRole = DevToolsRole;
+exports.HEARTBEAT_INTERVAL_MS = HEARTBEAT_INTERVAL_MS;
+exports.HEARTBEAT_TIMEOUT_MS = HEARTBEAT_TIMEOUT_MS;
+exports.MAX_SNAPSHOT_BYTES = MAX_SNAPSHOT_BYTES;
+exports.MessageType = MessageType;
+exports.REFRESH_TIMEOUT_MS = REFRESH_TIMEOUT_MS;
+exports.SNAPSHOT_API_PATH = SNAPSHOT_API_PATH;
+exports.SNAPSHOT_KIND_HEADER = SNAPSHOT_KIND_HEADER;
+exports.SNAPSHOT_MIME_HEADER = SNAPSHOT_MIME_HEADER;
+exports.SNAPSHOT_NAME_HEADER = SNAPSHOT_NAME_HEADER;
+exports.SQLITE_SNAPSHOT_MIME_TYPE = SQLITE_SNAPSHOT_MIME_TYPE;
+exports.SYNC_TIMEOUT_MS = SYNC_TIMEOUT_MS;
+exports.buildDevToolsHttpUrl = buildDevToolsHttpUrl;
+exports.buildDevToolsWsUrl = buildDevToolsWsUrl;
+exports.buildDeviceSnapshotUrl = buildDeviceSnapshotUrl;
+exports.buildSnapshotUrl = buildSnapshotUrl;
+exports.createDevToolsClient = createDevToolsClient;
+exports.createExpoSqliteAdapter = createExpoSqliteAdapter;
+exports.createExpoSqliteInspector = createExpoSqliteInspector;
+exports.createInspectorForSnapshot = createInspectorForSnapshot;
+exports.createMessage = createMessage;
+exports.detectExpoSqlite = detectExpoSqlite;
+exports.detectExpoSqliteInspectable = detectExpoSqliteInspectable;
+exports.fetchSnapshot = fetchSnapshot;
+exports.getAdapterRegistry = getAdapterRegistry;
+exports.getInspectorRegistry = getInspectorRegistry;
+exports.handleDeviceSnapshotUpload = handleDeviceSnapshotUpload;
+exports.isBroadcastMessage = isBroadcastMessage;
+exports.isClientMessage = isClientMessage;
+exports.isDeviceStatusMessage = isDeviceStatusMessage;
+exports.isEditableDatabaseAdapter = isEditableDatabaseAdapter;
+exports.isPingMessage = isPingMessage;
+exports.isPongMessage = isPongMessage;
+exports.isRefreshErrorMessage = isRefreshErrorMessage;
+exports.isRefreshRequestMessage = isRefreshRequestMessage;
+exports.isRefreshStatusMessage = isRefreshStatusMessage;
+exports.isRegisterMessage = isRegisterMessage;
+exports.isServerMessage = isServerMessage;
+exports.isSnapshotReadyMessage = isSnapshotReadyMessage;
+exports.isSnapshotUploadRequestedMessage = isSnapshotUploadRequestedMessage;
+exports.isWritableDatabaseAdapter = isWritableDatabaseAdapter;
+exports.readDatabaseKindMarker = readDatabaseKindMarker;
+exports.registerBuiltInAdapters = registerBuiltInAdapters;
+exports.registerSqliteAdapter = registerSqliteAdapter;
+exports.resolveAdapter = resolveAdapter;
+exports.sqliteAdapterDefinition = sqliteAdapterDefinition;
+exports.wsUrlToHttpUrl = wsUrlToHttpUrl;
+//# sourceMappingURL=native.cjs.map
+//# sourceMappingURL=native.cjs.map