database-devtools 0.1.0

package/dist/server/index.cjs

@@ -0,0 +1,1948 @@
+'use strict';
+
+var express2 = require('express');
+var http = require('http');
+var fs = require('fs');
+var path4 = require('path');
+var ws = require('ws');
+var promises = require('fs/promises');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var express2__default = /*#__PURE__*/_interopDefault(express2);
+var path4__default = /*#__PURE__*/_interopDefault(path4);
+
+// src/server/createDevToolsServer.ts
+
+// 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 PROJECT_DATABASE_API_PATH = "/api/project/database";
+var PROJECT_DATABASE_META_API_PATH = "/api/project/database/meta";
+var PROJECT_DATABASES_API_PATH = "/api/project/databases";
+var PROJECT_DEVICE_EXPORTS_API_PATH = "/api/project/devices";
+var REFRESH_TIMEOUT_MS = 6e4;
+var WRITE_TRANSACTION_TIMEOUT_MS = 5 * 60 * 1e3;
+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 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 isExportSnapshotRequestMessage(value) {
+  if (!hasMessageType(value) || value.type !== MessageType.EXPORT_SNAPSHOT_REQUEST) {
+    return false;
+  }
+  const message = value;
+  return message.refreshType === "snapshot";
+}
+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";
+}
+
+// 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/utils/logger.ts
+var RESET = "\x1B[0m";
+var GREEN = "\x1B[32m";
+var YELLOW = "\x1B[33m";
+var CYAN = "\x1B[36m";
+var RED = "\x1B[31m";
+var DIM = "\x1B[2m";
+var PREFIX = `${DIM}[database-devtools]${RESET}`;
+function log(color, symbol, message) {
+  console.log(`${PREFIX} ${color}${symbol}${RESET} ${message}`);
+}
+var logger = {
+  browserConnected(connectionId) {
+    const suffix = connectionId ? ` ${DIM}(${connectionId})${RESET}` : "";
+    log(GREEN, "\u2713", `Browser Connected${suffix}`);
+  },
+  browserDisconnected(connectionId) {
+    const suffix = connectionId ? ` ${DIM}(${connectionId})${RESET}` : "";
+    log(YELLOW, "\u2713", `Browser Disconnected${suffix}`);
+  },
+  mobileConnected(deviceId) {
+    const suffix = deviceId ? ` ${DIM}(deviceId: ${deviceId})${RESET}` : "";
+    log(GREEN, "\u2713", `Mobile Connected${suffix}`);
+  },
+  mobileDisconnected(deviceId) {
+    const suffix = deviceId ? ` ${DIM}(deviceId: ${deviceId})${RESET}` : "";
+    log(YELLOW, "\u2713", `Mobile Disconnected${suffix}`);
+  },
+  broadcastSent(target) {
+    const suffix = target ? ` ${DIM}\u2192 ${target}${RESET}` : "";
+    log(CYAN, "\u2713", `Broadcast Sent${suffix}`);
+  },
+  serverStarted(url, wsUrl, webUiEnabled = false) {
+    log(GREEN, "\u2713", `Server started at ${url}`);
+    log(GREEN, "\u2713", `WebSocket endpoint ${wsUrl}`);
+    if (webUiEnabled) {
+      log(GREEN, "\u2713", `Browser UI available at ${url}`);
+    }
+  },
+  heartbeatTimeout(connectionId) {
+    log(RED, "\u2713", `Heartbeat timeout \u2014 removing ${connectionId}`);
+  },
+  refreshStarted(deviceId) {
+    log(CYAN, "\u21BB", `Refresh started ${DIM}(${deviceId})${RESET}`);
+  },
+  refreshUploaded(deviceId, bytes) {
+    log(GREEN, "\u21BB", `Snapshot uploaded ${DIM}(${deviceId}, ${bytes} bytes)${RESET}`);
+  },
+  refreshFailed(deviceId, code, message) {
+    log(RED, "\u21BB", `Refresh failed ${DIM}(${deviceId}: ${code})${RESET} ${message}`);
+  },
+  /** @deprecated Use refreshStarted */
+  syncStarted(syncId, deviceId) {
+    this.refreshStarted(deviceId);
+  },
+  /** @deprecated Use refreshUploaded */
+  syncUploaded(syncId, bytes) {
+    this.refreshUploaded(syncId, bytes);
+  },
+  /** @deprecated Use refreshFailed */
+  syncFailed(syncId, code, message) {
+    this.refreshFailed(syncId, code, message);
+  },
+  error(message) {
+    log(RED, "\u2717", message);
+  }
+};
+function shouldServeSpa(request) {
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    return false;
+  }
+  if (request.path.startsWith("/api")) {
+    return false;
+  }
+  if (request.path === "/health") {
+    return false;
+  }
+  return true;
+}
+function attachWebUi(app, webDistPath) {
+  const indexPath = path4__default.default.join(webDistPath, "index.html");
+  if (!fs.existsSync(indexPath)) {
+    return;
+  }
+  app.use(
+    express2__default.default.static(webDistPath, {
+      index: false,
+      setHeaders(response, filePath) {
+        if (filePath.endsWith(".wasm")) {
+          response.setHeader("Content-Type", "application/wasm");
+        }
+      }
+    })
+  );
+  app.get("*", (request, response, next) => {
+    if (!shouldServeSpa(request)) {
+      next();
+      return;
+    }
+    response.sendFile(indexPath);
+  });
+}
+function attachWebSocket(httpServer, connectionManager, router, heartbeat, refreshCoordinator, writeCoordinator, options) {
+  const wss = new ws.WebSocketServer({ server: httpServer, path: DEVTOOLS_WS_PATH });
+  const handleDisconnect = (socket) => {
+    const client = connectionManager.remove(socket);
+    if (!client) {
+      return;
+    }
+    if (client.role === DevToolsRole.MOBILE) {
+      if (client.deviceId) {
+        writeCoordinator.rollbackSessionsForDevice(client.deviceId);
+      }
+      logger.mobileDisconnected(client.deviceId);
+    } else {
+      writeCoordinator.rollbackSessionsOnBrowserDisconnect(client.connectionId);
+      logger.browserDisconnected(client.connectionId);
+    }
+    router.broadcastDeviceStatus();
+  };
+  wss.on("connection", (socket) => {
+    socket.on("message", (raw) => {
+      let parsed;
+      try {
+        parsed = JSON.parse(String(raw));
+      } catch {
+        return;
+      }
+      if (isRegisterMessage(parsed)) {
+        const existing = connectionManager.getBySocket(socket);
+        if (existing) {
+          return;
+        }
+        const client = connectionManager.add({
+          socket,
+          role: parsed.role,
+          deviceId: parsed.deviceId,
+          metadata: parsed.metadata
+        });
+        if (client.role === DevToolsRole.MOBILE) {
+          logger.mobileConnected(client.deviceId);
+          if (client.deviceId && options?.snapshotFileStore) {
+            void options.snapshotFileStore.reconcileOnMobileConnect({
+              deviceId: client.deviceId,
+              bundleId: client.metadata?.bundleId
+            }).finally(() => {
+              router.broadcastDeviceStatus();
+            });
+            return;
+          }
+        } else {
+          logger.browserConnected(client.connectionId);
+        }
+        router.broadcastDeviceStatus();
+        return;
+      }
+      if (isPongMessage(parsed)) {
+        connectionManager.updateLastPong(socket);
+        return;
+      }
+      if (isRefreshRequestMessage(parsed)) {
+        refreshCoordinator.handleRefreshRequest(socket, parsed);
+        return;
+      }
+      if (isExportSnapshotRequestMessage(parsed)) {
+        refreshCoordinator.handleMobileExportRequest(socket, parsed);
+        return;
+      }
+      if (isBeginTransactionRequestMessage(parsed)) {
+        writeCoordinator.handleBeginTransactionRequest(socket, parsed);
+        return;
+      }
+      if (isCommitTransactionRequestMessage(parsed)) {
+        writeCoordinator.handleCommitTransactionRequest(socket, parsed);
+        return;
+      }
+      if (isRollbackTransactionRequestMessage(parsed)) {
+        writeCoordinator.handleRollbackTransactionRequest(socket, parsed);
+        return;
+      }
+      if (isWriteRequestMessage(parsed)) {
+        writeCoordinator.handleWriteRequest(socket, parsed);
+        return;
+      }
+      if (isTransactionAckMessage(parsed)) {
+        writeCoordinator.handleTransactionAck(parsed);
+        return;
+      }
+      if (isWriteAckMessage(parsed)) {
+        writeCoordinator.handleWriteAck(parsed);
+      }
+    });
+    socket.on("close", () => {
+      handleDisconnect(socket);
+    });
+    socket.on("error", () => {
+      handleDisconnect(socket);
+    });
+  });
+  heartbeat.start();
+  return { wss };
+}
+
+// src/utils/ids.ts
+function generateConnectionId() {
+  return generateUniqueId("conn");
+}
+function generatePingId() {
+  return generateUniqueId("ping");
+}
+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/server/connectionManager.ts
+var ConnectionManager = class {
+  clients = /* @__PURE__ */ new Map();
+  add(input) {
+    const now = Date.now();
+    const client = {
+      socket: input.socket,
+      connectionId: generateConnectionId(),
+      role: input.role,
+      deviceId: input.deviceId,
+      metadata: input.metadata,
+      connectedAt: now,
+      lastPongAt: now
+    };
+    this.clients.set(input.socket, client);
+    return client;
+  }
+  remove(socket) {
+    const client = this.clients.get(socket);
+    if (client) {
+      this.clients.delete(socket);
+    }
+    return client;
+  }
+  getBySocket(socket) {
+    return this.clients.get(socket);
+  }
+  getByConnectionId(connectionId) {
+    for (const client of this.clients.values()) {
+      if (client.connectionId === connectionId) {
+        return client;
+      }
+    }
+    return void 0;
+  }
+  getByDeviceId(deviceId) {
+    for (const client of this.clients.values()) {
+      if (client.deviceId === deviceId) {
+        return client;
+      }
+    }
+    return void 0;
+  }
+  getByRole(role) {
+    return [...this.clients.values()].filter((client) => client.role === role);
+  }
+  updateLastPong(socket) {
+    const client = this.clients.get(socket);
+    if (client) {
+      client.lastPongAt = Date.now();
+    }
+  }
+  getAll() {
+    return [...this.clients.values()];
+  }
+};
+
+// src/server/cors.ts
+var ALLOWED_METHODS = "GET, POST, OPTIONS";
+var ALLOWED_HEADERS = [
+  "Content-Type",
+  SNAPSHOT_KIND_HEADER,
+  SNAPSHOT_MIME_HEADER,
+  SNAPSHOT_NAME_HEADER
+].join(", ");
+function resolveCorsOrigin(requestOrigin, configuredOrigin) {
+  if (configuredOrigin) {
+    return configuredOrigin;
+  }
+  if (!requestOrigin) {
+    return "*";
+  }
+  try {
+    const url = new URL(requestOrigin);
+    const isLocalDev = url.hostname === "localhost" || url.hostname === "127.0.0.1" || url.hostname === "10.0.2.2";
+    if (isLocalDev) {
+      return requestOrigin;
+    }
+  } catch {
+    return "*";
+  }
+  return "*";
+}
+function createCorsMiddleware(options = {}) {
+  const configuredOrigin = options.allowedOrigin ?? process.env.DATABASE_DEVTOOLS_CORS_ORIGIN;
+  return (request, response, next) => {
+    const origin = resolveCorsOrigin(request.header("origin"), configuredOrigin);
+    response.setHeader("Access-Control-Allow-Origin", origin);
+    response.setHeader("Access-Control-Allow-Methods", ALLOWED_METHODS);
+    response.setHeader("Access-Control-Allow-Headers", ALLOWED_HEADERS);
+    response.setHeader("Vary", "Origin");
+    if (request.method === "OPTIONS") {
+      response.status(204).end();
+      return;
+    }
+    next();
+  };
+}
+
+// src/server/deviceRegistry.ts
+var DeviceRegistry = class {
+  constructor(connectionManager) {
+    this.connectionManager = connectionManager;
+  }
+  connectionManager;
+  snapshot() {
+    const browsers = this.connectionManager.getByRole(DevToolsRole.BROWSER).map((client) => ({
+      connectionId: client.connectionId,
+      connectedAt: client.connectedAt
+    }));
+    const mobiles = this.connectionManager.getByRole(DevToolsRole.MOBILE).map((client) => ({
+      deviceId: client.deviceId ?? client.connectionId,
+      connectionId: client.connectionId,
+      connectedAt: client.connectedAt,
+      metadata: client.metadata
+    }));
+    return {
+      browserCount: browsers.length,
+      mobileCount: mobiles.length,
+      browsers,
+      mobiles
+    };
+  }
+};
+
+// src/server/heartbeat.ts
+var Heartbeat = class {
+  constructor(connectionManager, router) {
+    this.connectionManager = connectionManager;
+    this.router = router;
+  }
+  connectionManager;
+  router;
+  interval = null;
+  start() {
+    if (this.interval !== null) {
+      return;
+    }
+    this.interval = setInterval(() => {
+      this.pingAll();
+      this.removeStaleConnections();
+    }, HEARTBEAT_INTERVAL_MS);
+  }
+  stop() {
+    if (this.interval !== null) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+  }
+  pingAll() {
+    const pingId = generatePingId();
+    const message = createMessage({
+      type: MessageType.PING,
+      pingId
+    });
+    for (const client of this.connectionManager.getAll()) {
+      this.router.sendToSocket(client.socket, message);
+    }
+  }
+  removeStaleConnections() {
+    const now = Date.now();
+    for (const client of this.connectionManager.getAll()) {
+      if (now - client.lastPongAt > HEARTBEAT_INTERVAL_MS + HEARTBEAT_TIMEOUT_MS) {
+        logger.heartbeatTimeout(client.connectionId);
+        client.socket.terminate();
+        this.connectionManager.remove(client.socket);
+      }
+    }
+  }
+};
+
+// src/server/messageRouter.ts
+var MessageRouter = class {
+  constructor(connectionManager, deviceRegistry) {
+    this.connectionManager = connectionManager;
+    this.deviceRegistry = deviceRegistry;
+  }
+  connectionManager;
+  deviceRegistry;
+  sendToSocket(socket, message) {
+    if (socket.readyState === socket.OPEN) {
+      socket.send(JSON.stringify(message));
+    }
+  }
+  sendToBrowser(connectionId, message) {
+    const client = this.connectionManager.getByConnectionId(connectionId);
+    if (client?.role === DevToolsRole.BROWSER) {
+      this.sendToSocket(client.socket, message);
+    }
+  }
+  sendToMobile(deviceId, message) {
+    const client = this.connectionManager.getByDeviceId(deviceId);
+    if (client?.role === DevToolsRole.MOBILE) {
+      this.sendToSocket(client.socket, message);
+    }
+  }
+  broadcastToBrowsers(message) {
+    for (const client of this.connectionManager.getByRole(DevToolsRole.BROWSER)) {
+      this.sendToSocket(client.socket, message);
+    }
+    logger.broadcastSent("browsers");
+  }
+  broadcastToMobiles(message) {
+    for (const client of this.connectionManager.getByRole(DevToolsRole.MOBILE)) {
+      this.sendToSocket(client.socket, message);
+    }
+    logger.broadcastSent("mobiles");
+  }
+  broadcastToAll(message) {
+    for (const client of this.connectionManager.getAll()) {
+      this.sendToSocket(client.socket, message);
+    }
+    logger.broadcastSent("all");
+  }
+  broadcast(message, target = "all") {
+    const broadcastMessage = createMessage({
+      type: MessageType.BROADCAST,
+      payload: message
+    });
+    if (target === "browsers") {
+      this.broadcastToBrowsers(broadcastMessage);
+      return;
+    }
+    if (target === "mobiles") {
+      this.broadcastToMobiles(broadcastMessage);
+      return;
+    }
+    this.broadcastToAll(broadcastMessage);
+  }
+  broadcastDeviceStatus() {
+    const message = createMessage({
+      type: MessageType.DEVICE_STATUS,
+      payload: this.deviceRegistry.snapshot()
+    });
+    this.broadcastToAll(message);
+  }
+};
+
+// src/server/pendingRefreshStore.ts
+var PendingRefreshStore = class {
+  pendingByDevice = /* @__PURE__ */ new Map();
+  create(input) {
+    this.pendingByDevice.set(input.deviceId, input);
+  }
+  get(deviceId) {
+    return this.pendingByDevice.get(deviceId);
+  }
+  has(deviceId) {
+    return this.pendingByDevice.has(deviceId);
+  }
+  remove(deviceId) {
+    this.pendingByDevice.delete(deviceId);
+  }
+  getExpired(now = Date.now()) {
+    return [...this.pendingByDevice.values()].filter(
+      (pending) => now - pending.startedAt >= REFRESH_TIMEOUT_MS
+    );
+  }
+};
+
+// src/server/refreshCoordinator.ts
+var RefreshCoordinator = class {
+  constructor(connectionManager, router, pending, snapshots, snapshotFiles) {
+    this.connectionManager = connectionManager;
+    this.router = router;
+    this.pending = pending;
+    this.snapshots = snapshots;
+    this.snapshotFiles = snapshotFiles;
+  }
+  connectionManager;
+  router;
+  pending;
+  snapshots;
+  snapshotFiles;
+  handleRefreshRequest(browserSocket, message) {
+    const browser = this.connectionManager.getBySocket(browserSocket);
+    if (!browser || browser.role !== DevToolsRole.BROWSER) {
+      return;
+    }
+    if (message.refreshType !== "snapshot") {
+      this.sendRefreshError(browser.connectionId, {
+        deviceId: message.deviceId,
+        code: "INVALID_REQUEST",
+        message: `Unsupported refresh type: ${message.refreshType}`
+      });
+      return;
+    }
+    const mobile = this.connectionManager.getByDeviceId(message.deviceId);
+    if (!mobile) {
+      this.sendRefreshError(browser.connectionId, {
+        deviceId: message.deviceId,
+        code: "DEVICE_OFFLINE",
+        message: `Device ${message.deviceId} is not connected`
+      });
+      return;
+    }
+    if (this.pending.has(message.deviceId)) {
+      this.sendRefreshError(browser.connectionId, {
+        deviceId: message.deviceId,
+        code: "REFRESH_IN_PROGRESS",
+        message: "A refresh is already in progress for this device"
+      });
+      return;
+    }
+    this.pending.create({
+      deviceId: message.deviceId,
+      initiator: "browser",
+      browserConnectionId: browser.connectionId,
+      refreshType: message.refreshType,
+      startedAt: Date.now()
+    });
+    logger.refreshStarted(message.deviceId);
+    this.sendRefreshStatus(browser.connectionId, message.deviceId, "requested");
+    this.sendRefreshStatus(browser.connectionId, message.deviceId, "exporting");
+    this.requestMobileUpload(message.deviceId, message.refreshType);
+  }
+  handleMobileExportRequest(mobileSocket, message) {
+    const mobile = this.connectionManager.getBySocket(mobileSocket);
+    if (!mobile || mobile.role !== DevToolsRole.MOBILE || !mobile.deviceId) {
+      return;
+    }
+    if (message.refreshType !== "snapshot") {
+      this.sendExportSnapshotError(mobileSocket, {
+        code: "INVALID_REQUEST",
+        message: `Unsupported refresh type: ${message.refreshType}`
+      });
+      return;
+    }
+    if (this.pending.has(mobile.deviceId)) {
+      this.sendExportSnapshotError(mobileSocket, {
+        code: "REFRESH_IN_PROGRESS",
+        message: "An export is already in progress for this device"
+      });
+      return;
+    }
+    this.pending.create({
+      deviceId: mobile.deviceId,
+      initiator: "mobile",
+      notifyAllBrowsers: true,
+      refreshType: message.refreshType,
+      startedAt: Date.now()
+    });
+    logger.refreshStarted(mobile.deviceId);
+    this.requestMobileUpload(mobile.deviceId, message.refreshType);
+  }
+  async handleSnapshotUpload(deviceId, body, metadata) {
+    const pending = this.pending.get(deviceId);
+    if (!pending) {
+      return { ok: false, code: "SNAPSHOT_NOT_FOUND" };
+    }
+    if (pending.browserConnectionId) {
+      this.sendRefreshStatus(pending.browserConnectionId, deviceId, "uploading");
+    }
+    const stored = this.snapshots.set(deviceId, body, {
+      kind: metadata?.kind ?? "sqlite",
+      mimeType: metadata?.mimeType ?? "application/x-sqlite3",
+      databaseName: metadata?.databaseName
+    });
+    const mobile = this.connectionManager.getByDeviceId(deviceId);
+    await this.snapshotFiles?.persistDeviceSnapshot({
+      deviceId,
+      bytes: body,
+      kind: stored.kind,
+      mimeType: stored.mimeType,
+      databaseName: stored.databaseName,
+      bundleId: mobile?.metadata?.bundleId
+    });
+    logger.refreshUploaded(deviceId, body.byteLength);
+    const readyMessage = createMessage({
+      type: MessageType.SNAPSHOT_READY,
+      deviceId,
+      size: body.byteLength,
+      exportedAt: stored.exportedAt,
+      kind: stored.kind,
+      mimeType: stored.mimeType,
+      ...stored.databaseName ? { databaseName: stored.databaseName } : {}
+    });
+    if (pending.notifyAllBrowsers) {
+      this.router.broadcastToBrowsers(readyMessage);
+    } else if (pending.browserConnectionId) {
+      this.sendRefreshStatus(pending.browserConnectionId, deviceId, "ready");
+      this.router.sendToBrowser(pending.browserConnectionId, readyMessage);
+    }
+    this.pending.remove(deviceId);
+    return { ok: true, stored: readyMessage };
+  }
+  getSnapshot(deviceId) {
+    return this.snapshots.getBytes(deviceId);
+  }
+  async getSnapshotAsync(deviceId) {
+    if (this.snapshotFiles) {
+      const fromDisk = await this.snapshotFiles.readDeviceSnapshot(deviceId);
+      if (fromDisk) {
+        return fromDisk;
+      }
+    }
+    return this.snapshots.getBytes(deviceId);
+  }
+  checkTimeouts() {
+    for (const pending of this.pending.getExpired()) {
+      if (pending.initiator === "mobile") {
+        this.failMobileExport(
+          pending.deviceId,
+          "TIMEOUT",
+          "Export timed out waiting for device upload"
+        );
+        continue;
+      }
+      if (pending.browserConnectionId) {
+        this.failRefresh(
+          pending.deviceId,
+          pending.browserConnectionId,
+          "TIMEOUT",
+          "Refresh timed out waiting for device upload"
+        );
+      } else {
+        this.pending.remove(pending.deviceId);
+      }
+    }
+  }
+  requestMobileUpload(deviceId, refreshType) {
+    this.router.sendToMobile(
+      deviceId,
+      createMessage({
+        type: MessageType.SNAPSHOT_UPLOAD_REQUESTED,
+        deviceId,
+        refreshType
+      })
+    );
+  }
+  failRefresh(deviceId, browserConnectionId, code, message) {
+    logger.refreshFailed(deviceId, code, message);
+    this.sendRefreshError(browserConnectionId, {
+      deviceId,
+      code,
+      message
+    });
+    this.pending.remove(deviceId);
+  }
+  failMobileExport(deviceId, code, message) {
+    logger.refreshFailed(deviceId, code, message);
+    const mobile = this.connectionManager.getByDeviceId(deviceId);
+    if (mobile) {
+      this.sendExportSnapshotError(mobile.socket, { code, message });
+    }
+    const refreshError = createMessage({
+      type: MessageType.REFRESH_ERROR,
+      deviceId,
+      code,
+      message
+    });
+    this.router.broadcastToBrowsers(refreshError);
+    this.pending.remove(deviceId);
+  }
+  sendRefreshStatus(browserConnectionId, deviceId, state) {
+    const statusMessage = createMessage({
+      type: MessageType.REFRESH_STATUS,
+      deviceId,
+      state
+    });
+    this.router.sendToBrowser(browserConnectionId, statusMessage);
+  }
+  sendRefreshError(browserConnectionId, input) {
+    const message = createMessage({
+      type: MessageType.REFRESH_ERROR,
+      deviceId: input.deviceId,
+      code: input.code,
+      message: input.message
+    });
+    this.router.sendToBrowser(browserConnectionId, message);
+    logger.refreshFailed(input.deviceId, input.code, input.message);
+  }
+  sendExportSnapshotError(mobileSocket, input) {
+    const message = createMessage({
+      type: MessageType.EXPORT_SNAPSHOT_ERROR,
+      code: input.code,
+      message: input.message
+    });
+    this.router.sendToSocket(mobileSocket, message);
+  }
+};
+var DEFAULT_DATA_DIR = ".devtools";
+var DEFAULT_DATABASE_RELATIVE_PATH = "databases/active.db";
+var DEFAULT_CONFIG = {
+  deviceSync: {
+    promoteLatestToActive: false
+  }
+};
+function resolveDataDir(explicitDir) {
+  const fromEnv = process.env.DATABASE_DEVTOOLS_DATA_DIR?.trim();
+  if (explicitDir?.trim()) {
+    return path4__default.default.resolve(explicitDir.trim());
+  }
+  if (fromEnv) {
+    return path4__default.default.resolve(fromEnv);
+  }
+  return path4__default.default.resolve(process.cwd(), DEFAULT_DATA_DIR);
+}
+function isPersistenceEnabled() {
+  const flag = process.env.DATABASE_DEVTOOLS_SNAPSHOT_PERSIST?.trim().toLowerCase();
+  if (flag === "0" || flag === "false" || flag === "off") {
+    return false;
+  }
+  return true;
+}
+function sanitizePathSegment(value) {
+  return value.replace(/[^a-zA-Z0-9._-]+/g, "_");
+}
+function resolveProjectPaths(dataDir) {
+  const databasesDir = path4__default.default.join(dataDir, "databases");
+  const devicesDir = path4__default.default.join(databasesDir, "devices");
+  const configPath = path4__default.default.join(dataDir, "devtools.json");
+  const manifestPath = path4__default.default.join(dataDir, "manifest.json");
+  return {
+    dataDir,
+    databasesDir,
+    devicesDir,
+    configPath,
+    manifestPath
+  };
+}
+async function ensureProjectDirectories(dataDir) {
+  const paths = resolveProjectPaths(dataDir);
+  await promises.mkdir(paths.devicesDir, { recursive: true });
+}
+async function writeDefaultProjectConfig(dataDir) {
+  const { configPath } = resolveProjectPaths(dataDir);
+  try {
+    await promises.readFile(configPath, "utf8");
+  } catch {
+    await promises.mkdir(dataDir, { recursive: true });
+    await promises.writeFile(configPath, `${JSON.stringify(DEFAULT_CONFIG, null, 2)}
+`, "utf8");
+  }
+}
+function deviceDatabaseFileName(deviceId) {
+  return `Database-${sanitizePathSegment(deviceId)}.db`;
+}
+var DEVICE_EXPORT_FILE_NAME = "database.db";
+function resolveDeviceStorageKey(input) {
+  const bundleId = input.bundleId?.trim();
+  if (bundleId) {
+    return sanitizePathSegment(bundleId);
+  }
+  return sanitizePathSegment(input.deviceId);
+}
+function deviceStorageManifestId(storageKey) {
+  return `device:${storageKey}`;
+}
+function deviceStorageRelativePath(storageKey) {
+  return path4__default.default.join("databases", "devices", storageKey, DEVICE_EXPORT_FILE_NAME).replace(/\\/g, "/");
+}
+function deviceDatabaseRelativePath(deviceId) {
+  const segment = sanitizePathSegment(deviceId);
+  return path4__default.default.join("databases", "devices", segment, deviceDatabaseFileName(deviceId)).replace(/\\/g, "/");
+}
+function deviceLatestRelativePath(deviceId) {
+  return path4__default.default.join("databases", "devices", sanitizePathSegment(deviceId), "latest.db").replace(/\\/g, "/");
+}
+async function readManifest(dataDir) {
+  const { manifestPath } = resolveProjectPaths(dataDir);
+  try {
+    const raw = await promises.readFile(manifestPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1 || !Array.isArray(parsed.entries)) {
+      return { version: 1, entries: [] };
+    }
+    return parsed;
+  } catch {
+    return { version: 1, entries: [] };
+  }
+}
+async function writeManifest(dataDir, manifest) {
+  const { manifestPath } = resolveProjectPaths(dataDir);
+  await promises.mkdir(dataDir, { recursive: true });
+  await promises.writeFile(manifestPath, `${JSON.stringify(manifest, null, 2)}
+`, "utf8");
+}
+function upsertManifestEntry(manifest, entry) {
+  const entries = manifest.entries.filter((item) => item.id !== entry.id);
+  entries.push(entry);
+  entries.sort((left, right) => right.updatedAt - left.updatedAt);
+  return {
+    version: manifest.version,
+    entries
+  };
+}
+
+// src/server/deviceExportStorage.ts
+function deriveStorageKeyFromEntry(entry) {
+  if (entry.storageKey) {
+    return entry.storageKey;
+  }
+  if (entry.bundleId) {
+    return sanitizePathSegment(entry.bundleId);
+  }
+  const match = entry.relativePath.match(/databases\/devices\/([^/]+)\//);
+  if (match?.[1]) {
+    return match[1];
+  }
+  if (entry.deviceId) {
+    return sanitizePathSegment(entry.deviceId);
+  }
+  return entry.id;
+}
+function findManifestEntryByDeviceId(entries, deviceId) {
+  return entries.find((entry) => entry.source === "device" && entry.deviceId === deviceId);
+}
+function selectDeviceExportEntriesToPrune(entries, keep) {
+  const keepManifestId = deviceStorageManifestId(keep.keepStorageKey);
+  return entries.filter((entry) => {
+    if (entry.source !== "device") {
+      return false;
+    }
+    if (entry.id === keepManifestId) {
+      return false;
+    }
+    const entryStorageKey = deriveStorageKeyFromEntry(entry);
+    if (entryStorageKey === keep.keepStorageKey) {
+      return true;
+    }
+    if (keep.bundleId && entry.bundleId === keep.bundleId) {
+      return true;
+    }
+    if (keep.bundleId && keep.databaseName && !entry.bundleId && entry.databaseName === keep.databaseName) {
+      return true;
+    }
+    if (!keep.bundleId && keep.databaseName && entry.databaseName === keep.databaseName && entry.deviceId !== keep.keepDeviceId) {
+      return true;
+    }
+    return false;
+  });
+}
+function dedupeListedDeviceExports(entries) {
+  const byStorageKey = /* @__PURE__ */ new Map();
+  for (const entry of entries) {
+    const storageKey = entry.storageKey ? entry.storageKey : entry.bundleId ? sanitizePathSegment(entry.bundleId) : entry.deviceId ? sanitizePathSegment(entry.deviceId) : entry.id;
+    const existing = byStorageKey.get(storageKey);
+    if (!existing || entry.updatedAt > existing.updatedAt) {
+      byStorageKey.set(storageKey, entry);
+    }
+  }
+  return [...byStorageKey.values()].sort((left, right) => right.updatedAt - left.updatedAt);
+}
+function reconcileLegacyManifestEntries(input) {
+  const deviceEntries = input.entries.filter((entry) => entry.source === "device");
+  const otherEntries = input.entries.filter((entry) => entry.source !== "device");
+  const groups = /* @__PURE__ */ new Map();
+  for (const entry of deviceEntries) {
+    const groupKey = entry.bundleId ? `bundle:${entry.bundleId}` : entry.databaseName ? `db:${entry.databaseName}` : `device:${deriveStorageKeyFromEntry(entry)}`;
+    const group = groups.get(groupKey) ?? [];
+    group.push(entry);
+    groups.set(groupKey, group);
+  }
+  const keptDeviceEntries = [];
+  for (const group of groups.values()) {
+    if (group.length === 1) {
+      keptDeviceEntries.push(group[0]);
+      continue;
+    }
+    const preferred = input.preferredDeviceId ? group.find((entry) => entry.deviceId === input.preferredDeviceId) : void 0;
+    const newest = [...group].sort((left, right) => right.updatedAt - left.updatedAt)[0];
+    keptDeviceEntries.push(preferred ?? newest);
+  }
+  return [...otherEntries, ...keptDeviceEntries].sort((left, right) => right.updatedAt - left.updatedAt);
+}
+function removedManifestEntries(before, after) {
+  const afterIds = new Set(after.map((entry) => entry.id));
+  return before.filter((entry) => !afterIds.has(entry.id));
+}
+var NORMALIZED_CONFIG = {
+  deviceSync: {
+    promoteLatestToActive: false
+  }
+};
+function stripLegacyActiveManifest(manifest) {
+  const entries = manifest.entries.filter(
+    (entry) => entry.source !== "active" && entry.id !== "active" && !entry.id.startsWith("import:")
+  );
+  return {
+    version: 1,
+    entries
+  };
+}
+function normalizeProjectConfig(config) {
+  return {
+    ...NORMALIZED_CONFIG,
+    deviceSync: {
+      ...NORMALIZED_CONFIG.deviceSync,
+      promoteLatestToActive: false
+    }
+  };
+}
+async function migrateLegacyActiveDatabase(dataDir) {
+  const { configPath } = resolveProjectPaths(dataDir);
+  const manifest = await readManifest(dataDir);
+  const stripped = stripLegacyActiveManifest(manifest);
+  const activeDbPath = path4__default.default.join(dataDir, DEFAULT_DATABASE_RELATIVE_PATH);
+  let changed = stripped.entries.length !== manifest.entries.length || Boolean(manifest.activeDatabase);
+  if (changed) {
+    await writeManifest(dataDir, stripped);
+  }
+  try {
+    await promises.stat(activeDbPath);
+    const hasDeviceExports = stripped.entries.some((entry) => entry.source === "device");
+    if (hasDeviceExports || manifest.entries.some((entry) => entry.source === "active")) {
+      await promises.rm(activeDbPath, { force: true });
+      changed = true;
+    }
+  } catch {
+  }
+  try {
+    const raw = await promises.readFile(configPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (parsed.defaultDatabase || parsed.deviceSync?.promoteLatestToActive) {
+      await promises.writeFile(
+        configPath,
+        `${JSON.stringify(normalizeProjectConfig(parsed), null, 2)}
+`,
+        "utf8"
+      );
+      changed = true;
+    }
+  } catch {
+  }
+  const importsDir = path4__default.default.join(dataDir, "databases", "imports");
+  try {
+    await promises.stat(importsDir);
+    await promises.rm(importsDir, { recursive: true, force: true });
+    changed = true;
+  } catch {
+  }
+  return changed;
+}
+
+// src/server/snapshotFileStore.ts
+var SnapshotFileStore = class {
+  dataDir;
+  enabled;
+  constructor(options) {
+    this.dataDir = resolveDataDir(options?.dataDir);
+    this.enabled = options?.enabled ?? isPersistenceEnabled();
+  }
+  getDataDir() {
+    return this.dataDir;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  async persistDeviceSnapshot(input) {
+    if (!this.enabled) {
+      return null;
+    }
+    await writeDefaultProjectConfig(this.dataDir);
+    await ensureProjectDirectories(this.dataDir);
+    const storageKey = resolveDeviceStorageKey({
+      bundleId: input.bundleId,
+      deviceId: input.deviceId
+    });
+    const deviceRelativePath = deviceStorageRelativePath(storageKey);
+    const deviceAbsolutePath = path4__default.default.join(this.dataDir, deviceRelativePath);
+    const exportedAt = Date.now();
+    await this.pruneDeviceExports({
+      keepStorageKey: storageKey,
+      keepDeviceId: input.deviceId,
+      bundleId: input.bundleId,
+      databaseName: input.databaseName
+    });
+    await promises.mkdir(path4__default.default.dirname(deviceAbsolutePath), { recursive: true });
+    await promises.writeFile(deviceAbsolutePath, input.bytes);
+    const manifest = await readManifest(this.dataDir);
+    const deviceEntry = {
+      id: deviceStorageManifestId(storageKey),
+      label: input.databaseName ?? `Device ${input.deviceId}`,
+      relativePath: deviceRelativePath.replace(/\\/g, "/"),
+      source: "device",
+      deviceId: input.deviceId,
+      bundleId: input.bundleId,
+      storageKey,
+      kind: input.kind,
+      mimeType: input.mimeType,
+      databaseName: input.databaseName,
+      size: input.bytes.byteLength,
+      updatedAt: exportedAt
+    };
+    const nextManifest = upsertManifestEntry(manifest, deviceEntry);
+    await writeManifest(this.dataDir, nextManifest);
+    return {
+      deviceRelativePath: deviceRelativePath.replace(/\\/g, "/"),
+      exportedAt,
+      size: input.bytes.byteLength
+    };
+  }
+  async reconcileOnMobileConnect(input) {
+    if (!this.enabled) {
+      return;
+    }
+    await this.reconcileLegacyExports(input.deviceId);
+    const storageKey = resolveDeviceStorageKey({
+      bundleId: input.bundleId,
+      deviceId: input.deviceId
+    });
+    const manifest = await readManifest(this.dataDir);
+    const canonicalEntry = manifest.entries.find(
+      (entry) => entry.source === "device" && entry.storageKey === storageKey
+    );
+    if (canonicalEntry && canonicalEntry.deviceId !== input.deviceId) {
+      const updated = upsertManifestEntry(manifest, {
+        ...canonicalEntry,
+        deviceId: input.deviceId,
+        bundleId: input.bundleId ?? canonicalEntry.bundleId,
+        updatedAt: Date.now()
+      });
+      await writeManifest(this.dataDir, updated);
+    }
+    await this.pruneDeviceExports({
+      keepStorageKey: storageKey,
+      keepDeviceId: input.deviceId,
+      bundleId: input.bundleId,
+      databaseName: canonicalEntry?.databaseName
+    });
+  }
+  async readDeviceSnapshot(deviceId) {
+    return this.readDeviceDatabase(deviceId);
+  }
+  async readDeviceDatabase(deviceId) {
+    if (!this.enabled) {
+      return void 0;
+    }
+    const resolved = await this.resolveDeviceDatabaseFile(deviceId);
+    if (!resolved) {
+      return void 0;
+    }
+    try {
+      return await promises.readFile(resolved.absolutePath);
+    } catch {
+      return void 0;
+    }
+  }
+  async getDeviceDatabaseMeta(deviceId) {
+    if (!this.enabled) {
+      return { exists: false, deviceId };
+    }
+    const resolved = await this.resolveDeviceDatabaseFile(deviceId);
+    if (!resolved) {
+      return { exists: false, deviceId };
+    }
+    try {
+      const fileStat = await promises.stat(resolved.absolutePath);
+      const manifest = await readManifest(this.dataDir);
+      const entry = manifest.entries.find(
+        (item) => item.deviceId === deviceId && item.source === "device"
+      );
+      return {
+        exists: true,
+        relativePath: resolved.relativePath,
+        absolutePath: resolved.absolutePath,
+        kind: entry?.kind ?? "sqlite",
+        mimeType: entry?.mimeType ?? SQLITE_SNAPSHOT_MIME_TYPE,
+        databaseName: entry?.databaseName ?? path4__default.default.basename(resolved.absolutePath),
+        size: fileStat.size,
+        updatedAt: entry?.updatedAt ?? fileStat.mtimeMs,
+        source: "device",
+        deviceId
+      };
+    } catch {
+      return { exists: false, deviceId, relativePath: resolved.relativePath };
+    }
+  }
+  async listDeviceExports() {
+    await this.reconcileLegacyExports();
+    const databases = await this.listDatabases();
+    const deviceExports = databases.filter((entry) => entry.source === "device" && entry.deviceId);
+    return dedupeListedDeviceExports(deviceExports);
+  }
+  async reconcileLegacyExports(preferredDeviceId) {
+    if (!this.enabled) {
+      return;
+    }
+    await migrateLegacyActiveDatabase(this.dataDir);
+    const manifest = await readManifest(this.dataDir);
+    const nextEntries = reconcileLegacyManifestEntries({
+      entries: manifest.entries,
+      preferredDeviceId
+    });
+    if (nextEntries.length === manifest.entries.length) {
+      const sameOrder = nextEntries.every((entry, index) => entry.id === manifest.entries[index]?.id);
+      if (sameOrder) {
+        return;
+      }
+    }
+    const removed = removedManifestEntries(manifest.entries, nextEntries);
+    for (const entry of removed) {
+      await this.deleteEntryFiles(entry);
+    }
+    await writeManifest(this.dataDir, {
+      ...manifest,
+      entries: nextEntries
+    });
+  }
+  async pruneDeviceExports(input) {
+    const manifest = await readManifest(this.dataDir);
+    const removed = selectDeviceExportEntriesToPrune(manifest.entries, input);
+    if (removed.length === 0) {
+      return;
+    }
+    for (const entry of removed) {
+      await this.deleteEntryFiles(entry);
+    }
+    const removedIds = new Set(removed.map((entry) => entry.id));
+    await writeManifest(this.dataDir, {
+      ...manifest,
+      entries: manifest.entries.filter((entry) => !removedIds.has(entry.id))
+    });
+  }
+  async deleteEntryFiles(entry) {
+    const absolutePath = path4__default.default.join(this.dataDir, entry.relativePath);
+    try {
+      await promises.rm(absolutePath, { force: true });
+    } catch {
+    }
+    try {
+      await promises.rm(path4__default.default.dirname(absolutePath), { recursive: true, force: true });
+    } catch {
+    }
+  }
+  manifestEntryToListed(entry, fileStat) {
+    return {
+      id: entry.id,
+      label: entry.label,
+      relativePath: entry.relativePath,
+      source: entry.source,
+      deviceId: entry.deviceId,
+      bundleId: entry.bundleId,
+      storageKey: entry.storageKey,
+      databaseName: entry.databaseName,
+      size: fileStat.size,
+      updatedAt: entry.updatedAt
+    };
+  }
+  async resolveDeviceDatabaseFile(deviceId) {
+    const manifest = await readManifest(this.dataDir);
+    const manifestEntry = findManifestEntryByDeviceId(manifest.entries, deviceId);
+    if (manifestEntry) {
+      const absolutePath2 = path4__default.default.join(this.dataDir, manifestEntry.relativePath);
+      try {
+        await promises.stat(absolutePath2);
+        return { relativePath: manifestEntry.relativePath, absolutePath: absolutePath2 };
+      } catch {
+      }
+    }
+    const candidates = [
+      deviceDatabaseRelativePath(deviceId),
+      deviceLatestRelativePath(deviceId)
+    ];
+    for (const relativePath of candidates) {
+      const absolutePath2 = path4__default.default.join(this.dataDir, relativePath);
+      try {
+        await promises.stat(absolutePath2);
+        return { relativePath, absolutePath: absolutePath2 };
+      } catch {
+      }
+    }
+    if (!manifestEntry) {
+      return void 0;
+    }
+    const absolutePath = path4__default.default.join(this.dataDir, manifestEntry.relativePath);
+    try {
+      await promises.stat(absolutePath);
+      return { relativePath: manifestEntry.relativePath, absolutePath };
+    } catch {
+      return void 0;
+    }
+  }
+  /** @deprecated Proxies to the newest device export for backward-compatible API callers. */
+  async readActiveDatabase() {
+    if (!this.enabled) {
+      return void 0;
+    }
+    const meta = await this.getActiveDatabaseMeta();
+    if (!meta.exists || !meta.deviceId) {
+      return void 0;
+    }
+    return this.readDeviceDatabase(meta.deviceId);
+  }
+  /** @deprecated Proxies to the newest device export for backward-compatible API callers. */
+  async getActiveDatabaseMeta() {
+    if (!this.enabled) {
+      return { exists: false };
+    }
+    await migrateLegacyActiveDatabase(this.dataDir);
+    const exports = await this.listDeviceExports();
+    const latest = exports[0];
+    if (!latest?.deviceId) {
+      return { exists: false };
+    }
+    return this.getDeviceDatabaseMeta(latest.deviceId);
+  }
+  async listDatabases() {
+    if (!this.enabled) {
+      return [];
+    }
+    await ensureProjectDirectories(this.dataDir);
+    await this.reconcileLegacyExports();
+    const manifest = await readManifest(this.dataDir);
+    const listed = /* @__PURE__ */ new Map();
+    for (const entry of manifest.entries) {
+      if (entry.source === "active" || entry.id.startsWith("import:")) {
+        continue;
+      }
+      const absolutePath = path4__default.default.join(this.dataDir, entry.relativePath);
+      try {
+        const fileStat = await promises.stat(absolutePath);
+        listed.set(entry.id, this.manifestEntryToListed(entry, fileStat));
+      } catch {
+      }
+    }
+    return [...listed.values()].sort((left, right) => right.updatedAt - left.updatedAt);
+  }
+  async readDatabaseByRelativePath(relativePath) {
+    if (!this.enabled) {
+      return void 0;
+    }
+    const normalized = relativePath.replace(/\\/g, "/");
+    const absolutePath = path4__default.default.resolve(this.dataDir, normalized);
+    const dataDirResolved = path4__default.default.resolve(this.dataDir);
+    if (!absolutePath.startsWith(dataDirResolved)) {
+      return void 0;
+    }
+    if (!normalized.toLowerCase().endsWith(".db")) {
+      return void 0;
+    }
+    try {
+      return await promises.readFile(absolutePath);
+    } catch {
+      return void 0;
+    }
+  }
+  getDeviceDirectoryName(deviceId) {
+    return sanitizePathSegment(deviceId);
+  }
+};
+
+// src/server/snapshotStore.ts
+var SnapshotStore = class {
+  snapshots = /* @__PURE__ */ new Map();
+  set(deviceId, bytes, metadata) {
+    const stored = {
+      deviceId,
+      bytes,
+      kind: metadata.kind,
+      mimeType: metadata.mimeType,
+      databaseName: metadata.databaseName,
+      exportedAt: Date.now()
+    };
+    this.snapshots.set(deviceId, stored);
+    return stored;
+  }
+  get(deviceId) {
+    return this.snapshots.get(deviceId);
+  }
+  getBytes(deviceId) {
+    return this.snapshots.get(deviceId)?.bytes;
+  }
+};
+
+// src/server/writeCoordinator.ts
+var WriteCoordinator = class {
+  constructor(connectionManager, router, sessions) {
+    this.connectionManager = connectionManager;
+    this.router = router;
+    this.sessions = sessions;
+  }
+  connectionManager;
+  router;
+  sessions;
+  handleBeginTransactionRequest(browserSocket, message) {
+    const browser = this.connectionManager.getBySocket(browserSocket);
+    if (!browser || browser.role !== DevToolsRole.BROWSER) {
+      return;
+    }
+    const mobile = this.connectionManager.getByDeviceId(message.deviceId);
+    if (!mobile) {
+      this.sendWriteError(browser.connectionId, {
+        transactionId: message.transactionId,
+        code: "DEVICE_OFFLINE",
+        message: `Device ${message.deviceId} is not connected`
+      });
+      return;
+    }
+    if (this.sessions.getActiveForDevice(message.deviceId)) {
+      this.sendWriteError(browser.connectionId, {
+        transactionId: message.transactionId,
+        code: "TRANSACTION_BUSY",
+        message: "A transaction is already open for this device"
+      });
+      return;
+    }
+    this.sessions.create({
+      transactionId: message.transactionId,
+      deviceId: message.deviceId,
+      browserConnectionId: browser.connectionId
+    });
+    logger.syncStarted(message.transactionId, message.deviceId);
+    this.router.sendToMobile(
+      message.deviceId,
+      createMessage({
+        type: MessageType.BEGIN_TRANSACTION,
+        transactionId: message.transactionId
+      })
+    );
+  }
+  handleCommitTransactionRequest(browserSocket, message) {
+    const browser = this.connectionManager.getBySocket(browserSocket);
+    const session = this.sessions.get(message.transactionId);
+    if (!browser || browser.role !== DevToolsRole.BROWSER || !session) {
+      return;
+    }
+    if (session.browserConnectionId !== browser.connectionId) {
+      return;
+    }
+    if (session.state !== "open") {
+      this.sendWriteError(browser.connectionId, {
+        transactionId: message.transactionId,
+        code: "NO_TRANSACTION",
+        message: "Transaction is not open"
+      });
+      return;
+    }
+    this.sessions.setState(message.transactionId, "committing");
+    this.router.sendToMobile(
+      session.deviceId,
+      createMessage({
+        type: MessageType.COMMIT_TRANSACTION,
+        transactionId: message.transactionId
+      })
+    );
+  }
+  handleRollbackTransactionRequest(browserSocket, message) {
+    const browser = this.connectionManager.getBySocket(browserSocket);
+    const session = this.sessions.get(message.transactionId);
+    if (!browser || browser.role !== DevToolsRole.BROWSER || !session) {
+      return;
+    }
+    if (session.browserConnectionId !== browser.connectionId) {
+      return;
+    }
+    if (session.state !== "open" && session.state !== "committing") {
+      this.sendWriteError(browser.connectionId, {
+        transactionId: message.transactionId,
+        code: "NO_TRANSACTION",
+        message: "Transaction is not open"
+      });
+      return;
+    }
+    this.sessions.setState(message.transactionId, "rolling_back");
+    this.router.sendToMobile(
+      session.deviceId,
+      createMessage({
+        type: MessageType.ROLLBACK_TRANSACTION,
+        transactionId: message.transactionId
+      })
+    );
+  }
+  handleWriteRequest(browserSocket, message) {
+    const browser = this.connectionManager.getBySocket(browserSocket);
+    const session = this.sessions.get(message.transactionId);
+    if (!browser || browser.role !== DevToolsRole.BROWSER || !session) {
+      return;
+    }
+    if (session.browserConnectionId !== browser.connectionId) {
+      return;
+    }
+    if (session.state !== "open") {
+      this.sendWriteError(browser.connectionId, {
+        transactionId: message.transactionId,
+        writeId: message.writeId,
+        code: "NO_TRANSACTION",
+        message: "Transaction is not open"
+      });
+      return;
+    }
+    const mobile = this.connectionManager.getByDeviceId(session.deviceId);
+    if (!mobile) {
+      this.sendWriteError(browser.connectionId, {
+        transactionId: message.transactionId,
+        writeId: message.writeId,
+        code: "DEVICE_OFFLINE",
+        message: `Device ${session.deviceId} is not connected`
+      });
+      return;
+    }
+    this.sessions.incrementPendingWrites(message.transactionId);
+    this.router.sendToMobile(
+      session.deviceId,
+      createMessage({
+        type: MessageType.EXECUTE_WRITE,
+        writeId: message.writeId,
+        transactionId: message.transactionId,
+        operation: message.operation
+      })
+    );
+  }
+  handleTransactionAck(message) {
+    const session = this.sessions.get(message.transactionId);
+    if (!session) {
+      return;
+    }
+    if (!message.ok) {
+      this.sessions.setState(message.transactionId, "failed");
+      this.sendWriteError(session.browserConnectionId, {
+        transactionId: message.transactionId,
+        code: message.action === "begin" ? "ADAPTER_ERROR" : "WRITE_FAILED",
+        message: message.message ?? `Transaction ${message.action} failed`
+      });
+      this.sessions.remove(message.transactionId);
+      return;
+    }
+    if (message.action === "begin") {
+      this.sendTransactionStatus(session.browserConnectionId, {
+        transactionId: message.transactionId,
+        deviceId: session.deviceId,
+        state: "open"
+      });
+      return;
+    }
+    if (message.action === "commit") {
+      this.sendTransactionStatus(session.browserConnectionId, {
+        transactionId: message.transactionId,
+        deviceId: session.deviceId,
+        state: "idle"
+      });
+      this.sessions.remove(message.transactionId);
+      return;
+    }
+    this.sendTransactionStatus(session.browserConnectionId, {
+      transactionId: message.transactionId,
+      deviceId: session.deviceId,
+      state: "idle",
+      message: message.message
+    });
+    this.sessions.remove(message.transactionId);
+  }
+  handleWriteAck(message) {
+    const session = this.sessions.get(message.transactionId);
+    if (!session) {
+      return;
+    }
+    this.sessions.decrementPendingWrites(message.transactionId);
+    if (!message.ok) {
+      this.sendWriteError(session.browserConnectionId, {
+        transactionId: message.transactionId,
+        writeId: message.writeId,
+        code: "WRITE_FAILED",
+        message: message.message ?? "Write operation failed"
+      });
+      return;
+    }
+    this.router.sendToBrowser(
+      session.browserConnectionId,
+      createMessage({
+        type: MessageType.WRITE_RESULT,
+        writeId: message.writeId,
+        transactionId: message.transactionId,
+        rowsAffected: message.rowsAffected ?? 0
+      })
+    );
+  }
+  checkTimeouts() {
+    for (const session of this.sessions.getExpired()) {
+      this.rollbackSession(session, "TIMEOUT", "Write transaction timed out");
+    }
+  }
+  rollbackSessionsOnBrowserDisconnect(browserConnectionId) {
+    for (const session of this.sessions.getByBrowserConnectionId(browserConnectionId)) {
+      this.rollbackSession(session, "NO_TRANSACTION", "Browser disconnected");
+    }
+  }
+  rollbackSessionsForDevice(deviceId) {
+    for (const session of this.sessions.getByDeviceId(deviceId)) {
+      this.rollbackSession(session, "NO_TRANSACTION", "Device disconnected");
+    }
+  }
+  rollbackSession(session, code, message) {
+    logger.syncFailed(session.transactionId, code, message);
+    this.sendWriteError(session.browserConnectionId, {
+      transactionId: session.transactionId,
+      code,
+      message
+    });
+    this.router.sendToMobile(
+      session.deviceId,
+      createMessage({
+        type: MessageType.ROLLBACK_TRANSACTION,
+        transactionId: session.transactionId
+      })
+    );
+    this.sessions.remove(session.transactionId);
+  }
+  sendTransactionStatus(browserConnectionId, payload) {
+    this.router.sendToBrowser(
+      browserConnectionId,
+      createMessage({
+        type: MessageType.TRANSACTION_STATUS,
+        ...payload
+      })
+    );
+  }
+  sendWriteError(browserConnectionId, payload) {
+    this.router.sendToBrowser(
+      browserConnectionId,
+      createMessage({
+        type: MessageType.WRITE_ERROR,
+        ...payload
+      })
+    );
+  }
+};
+
+// src/server/writeSessionManager.ts
+var WriteSessionManager = class {
+  sessions = /* @__PURE__ */ new Map();
+  activeByDevice = /* @__PURE__ */ new Map();
+  create(input) {
+    const session = {
+      transactionId: input.transactionId,
+      deviceId: input.deviceId,
+      browserConnectionId: input.browserConnectionId,
+      state: "opening",
+      pendingWrites: 0,
+      createdAt: Date.now()
+    };
+    this.sessions.set(input.transactionId, session);
+    this.activeByDevice.set(input.deviceId, input.transactionId);
+    return session;
+  }
+  get(transactionId) {
+    return this.sessions.get(transactionId);
+  }
+  getActiveForDevice(deviceId) {
+    const transactionId = this.activeByDevice.get(deviceId);
+    if (!transactionId) {
+      return void 0;
+    }
+    return this.sessions.get(transactionId);
+  }
+  setState(transactionId, state) {
+    const session = this.sessions.get(transactionId);
+    if (!session) {
+      return void 0;
+    }
+    session.state = state;
+    return session;
+  }
+  incrementPendingWrites(transactionId) {
+    const session = this.sessions.get(transactionId);
+    if (!session) {
+      return void 0;
+    }
+    session.pendingWrites += 1;
+    return session;
+  }
+  decrementPendingWrites(transactionId) {
+    const session = this.sessions.get(transactionId);
+    if (!session) {
+      return void 0;
+    }
+    session.pendingWrites = Math.max(0, session.pendingWrites - 1);
+    return session;
+  }
+  remove(transactionId) {
+    const session = this.sessions.get(transactionId);
+    if (!session) {
+      return;
+    }
+    if (this.activeByDevice.get(session.deviceId) === transactionId) {
+      this.activeByDevice.delete(session.deviceId);
+    }
+    this.sessions.delete(transactionId);
+  }
+  getExpired(now = Date.now()) {
+    return [...this.sessions.values()].filter((session) => {
+      if (session.state === "idle" || session.state === "failed") {
+        return false;
+      }
+      return now - session.createdAt >= WRITE_TRANSACTION_TIMEOUT_MS;
+    });
+  }
+  getByBrowserConnectionId(browserConnectionId) {
+    return [...this.sessions.values()].filter(
+      (session) => session.browserConnectionId === browserConnectionId
+    );
+  }
+  getByDeviceId(deviceId) {
+    return [...this.sessions.values()].filter((session) => session.deviceId === deviceId);
+  }
+};
+
+// src/server/createDevToolsServer.ts
+async function createDevToolsServer(options = {}) {
+  const host = options.host ?? DEFAULT_DEVTOOLS_HOST;
+  const port = options.port ?? DEFAULT_DEVTOOLS_PORT;
+  const app = express2__default.default();
+  const connectionManager = new ConnectionManager();
+  const deviceRegistry = new DeviceRegistry(connectionManager);
+  const router = new MessageRouter(connectionManager, deviceRegistry);
+  const heartbeat = new Heartbeat(connectionManager, router);
+  const snapshotStore = new SnapshotStore();
+  const snapshotFileStore = new SnapshotFileStore({
+    dataDir: options.dataDir,
+    enabled: options.snapshotPersistence
+  });
+  const pendingRefreshStore = new PendingRefreshStore();
+  const writeSessions = new WriteSessionManager();
+  const refreshCoordinator = new RefreshCoordinator(
+    connectionManager,
+    router,
+    pendingRefreshStore,
+    snapshotStore,
+    snapshotFileStore
+  );
+  const writeCoordinator = new WriteCoordinator(connectionManager, router, writeSessions);
+  app.use(createCorsMiddleware());
+  app.get("/health", (_request, response) => {
+    response.json({ ok: true, ...deviceRegistry.snapshot() });
+  });
+  app.post(
+    `${DEVICE_SNAPSHOT_API_PATH}/:deviceId/snapshot`,
+    express2__default.default.raw({ type: "application/octet-stream", limit: MAX_SNAPSHOT_BYTES }),
+    async (request, response) => {
+      const deviceId = decodeURIComponent(request.params.deviceId);
+      const body = request.body;
+      if (!Buffer.isBuffer(body) || body.length === 0) {
+        response.status(400).json({ ok: false, error: "Empty snapshot body" });
+        return;
+      }
+      const kindHeader = request.header(SNAPSHOT_KIND_HEADER);
+      const mimeHeader = request.header(SNAPSHOT_MIME_HEADER);
+      const nameHeader = request.header(SNAPSHOT_NAME_HEADER);
+      const result = await refreshCoordinator.handleSnapshotUpload(deviceId, body, {
+        kind: typeof kindHeader === "string" ? kindHeader : void 0,
+        mimeType: typeof mimeHeader === "string" ? mimeHeader : void 0,
+        databaseName: typeof nameHeader === "string" ? nameHeader : void 0
+      });
+      if (!result.ok) {
+        response.status(result.code === "SNAPSHOT_NOT_FOUND" ? 404 : 400).json({
+          ok: false,
+          error: result.code
+        });
+        return;
+      }
+      response.status(201).json({ ok: true, deviceId, size: body.byteLength });
+    }
+  );
+  app.get(`${DEVICE_SNAPSHOT_API_PATH}/:deviceId/snapshot`, async (request, response) => {
+    const deviceId = decodeURIComponent(request.params.deviceId);
+    const snapshot = await refreshCoordinator.getSnapshotAsync(deviceId);
+    if (!snapshot) {
+      response.status(404).json({ ok: false, error: "SNAPSHOT_NOT_FOUND" });
+      return;
+    }
+    response.status(200).set("Content-Type", "application/octet-stream").send(snapshot);
+  });
+  app.get(PROJECT_DATABASE_META_API_PATH, async (_request, response) => {
+    const meta = await snapshotFileStore.getActiveDatabaseMeta();
+    response.json(meta);
+  });
+  app.get(PROJECT_DATABASES_API_PATH, async (_request, response) => {
+    const databases = await snapshotFileStore.listDatabases();
+    response.json({ databases });
+  });
+  app.get(PROJECT_DEVICE_EXPORTS_API_PATH, async (_request, response) => {
+    const devices = await snapshotFileStore.listDeviceExports();
+    response.json({ devices });
+  });
+  app.get(`${PROJECT_DEVICE_EXPORTS_API_PATH}/:deviceId/database/meta`, async (request, response) => {
+    const deviceId = decodeURIComponent(request.params.deviceId);
+    const meta = await snapshotFileStore.getDeviceDatabaseMeta(deviceId);
+    response.json(meta);
+  });
+  app.get(`${PROJECT_DEVICE_EXPORTS_API_PATH}/:deviceId/database`, async (request, response) => {
+    const deviceId = decodeURIComponent(request.params.deviceId);
+    const meta = await snapshotFileStore.getDeviceDatabaseMeta(deviceId);
+    if (!meta.exists) {
+      response.status(404).json({ ok: false, error: "DEVICE_DATABASE_NOT_FOUND", deviceId });
+      return;
+    }
+    const bytes = await snapshotFileStore.readDeviceDatabase(deviceId);
+    if (!bytes) {
+      response.status(404).json({ ok: false, error: "DEVICE_DATABASE_NOT_FOUND", deviceId });
+      return;
+    }
+    response.status(200).set("Content-Type", meta.mimeType ?? SQLITE_SNAPSHOT_MIME_TYPE).send(bytes);
+  });
+  app.get(PROJECT_DATABASE_API_PATH, async (_request, response) => {
+    const meta = await snapshotFileStore.getActiveDatabaseMeta();
+    if (!meta.exists) {
+      response.status(404).json({ ok: false, error: "PROJECT_DATABASE_NOT_FOUND" });
+      return;
+    }
+    const bytes = await snapshotFileStore.readActiveDatabase();
+    if (!bytes) {
+      response.status(404).json({ ok: false, error: "PROJECT_DATABASE_NOT_FOUND" });
+      return;
+    }
+    response.status(200).set("Content-Type", meta.mimeType ?? SQLITE_SNAPSHOT_MIME_TYPE).send(bytes);
+  });
+  if (options.webDistPath) {
+    attachWebUi(app, options.webDistPath);
+  }
+  const httpServer = http.createServer(app);
+  attachWebSocket(
+    httpServer,
+    connectionManager,
+    router,
+    heartbeat,
+    refreshCoordinator,
+    writeCoordinator,
+    { snapshotFileStore }
+  );
+  const refreshTimeoutInterval = setInterval(() => {
+    refreshCoordinator.checkTimeouts();
+    writeCoordinator.checkTimeouts();
+  }, 5e3);
+  if (snapshotFileStore.isEnabled()) {
+    await snapshotFileStore.listDeviceExports();
+  }
+  await new Promise((resolve, reject) => {
+    httpServer.once("error", reject);
+    httpServer.listen(port, host, () => resolve());
+  });
+  const displayHost = host === "0.0.0.0" ? "localhost" : host;
+  const httpUrl = buildDevToolsHttpUrl(displayHost, port);
+  const wsUrl = buildDevToolsWsUrl(displayHost, port);
+  const webUiEnabled = Boolean(options.webDistPath);
+  logger.serverStarted(httpUrl, wsUrl, webUiEnabled);
+  return {
+    app,
+    httpServer,
+    connectionManager,
+    deviceRegistry,
+    router,
+    heartbeat,
+    snapshotStore,
+    snapshotFileStore,
+    pendingRefreshStore,
+    writeSessions,
+    refreshCoordinator,
+    writeCoordinator,
+    urls: {
+      httpUrl,
+      wsUrl,
+      webUiEnabled
+    },
+    close: () => new Promise((resolve, reject) => {
+      clearInterval(refreshTimeoutInterval);
+      heartbeat.stop();
+      httpServer.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    })
+  };
+}
+
+exports.ConnectionManager = ConnectionManager;
+exports.DeviceRegistry = DeviceRegistry;
+exports.Heartbeat = Heartbeat;
+exports.MessageRouter = MessageRouter;
+exports.PendingRefreshStore = PendingRefreshStore;
+exports.RefreshCoordinator = RefreshCoordinator;
+exports.SnapshotStore = SnapshotStore;
+exports.createCorsMiddleware = createCorsMiddleware;
+exports.createDevToolsServer = createDevToolsServer;
+exports.resolveCorsOrigin = resolveCorsOrigin;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map