database-devtools 0.1.0

package/dist/createDevToolsServer-B7NQ_5H4.d.cts

@@ -0,0 +1,292 @@
+import express from 'express';
+import { Server } from 'node:http';
+import { WebSocket } from 'ws';
+import { DevToolsRole, DeviceMetadata, DeviceStatusPayload, ServerMessage, RefreshType, RefreshInitiator, RefreshRequestMessage, ExportSnapshotRequestMessage, SnapshotReadyMessage, RefreshErrorCode, TransactionStatusState, BeginTransactionRequestMessage, CommitTransactionRequestMessage, RollbackTransactionRequestMessage, WriteRequestMessage, TransactionAckMessage, WriteAckMessage } from './types/protocol.cjs';
+
+type ConnectedClient = {
+    socket: WebSocket;
+    connectionId: string;
+    role: DevToolsRole;
+    deviceId?: string;
+    metadata?: DeviceMetadata;
+    connectedAt: number;
+    lastPongAt: number;
+};
+type RegisterClientInput = {
+    socket: WebSocket;
+    role: DevToolsRole;
+    deviceId?: string;
+    metadata?: DeviceMetadata;
+};
+declare class ConnectionManager {
+    private readonly clients;
+    add(input: RegisterClientInput): ConnectedClient;
+    remove(socket: WebSocket): ConnectedClient | undefined;
+    getBySocket(socket: WebSocket): ConnectedClient | undefined;
+    getByConnectionId(connectionId: string): ConnectedClient | undefined;
+    getByDeviceId(deviceId: string): ConnectedClient | undefined;
+    getByRole(role: DevToolsRole): ConnectedClient[];
+    updateLastPong(socket: WebSocket): void;
+    getAll(): ConnectedClient[];
+}
+
+declare class DeviceRegistry {
+    private readonly connectionManager;
+    constructor(connectionManager: ConnectionManager);
+    snapshot(): DeviceStatusPayload;
+}
+
+type OutboundMessage = ServerMessage;
+declare class MessageRouter {
+    private readonly connectionManager;
+    private readonly deviceRegistry;
+    constructor(connectionManager: ConnectionManager, deviceRegistry: DeviceRegistry);
+    sendToSocket(socket: WebSocket, message: OutboundMessage): void;
+    sendToBrowser(connectionId: string, message: OutboundMessage): void;
+    sendToMobile(deviceId: string, message: OutboundMessage): void;
+    broadcastToBrowsers(message: OutboundMessage): void;
+    broadcastToMobiles(message: OutboundMessage): void;
+    broadcastToAll(message: OutboundMessage): void;
+    broadcast(message: unknown, target?: 'browsers' | 'mobiles' | 'all'): void;
+    broadcastDeviceStatus(): void;
+}
+
+declare class Heartbeat {
+    private readonly connectionManager;
+    private readonly router;
+    private interval;
+    constructor(connectionManager: ConnectionManager, router: MessageRouter);
+    start(): void;
+    stop(): void;
+    private pingAll;
+    private removeStaleConnections;
+}
+
+type PendingRefresh = {
+    deviceId: string;
+    refreshType: RefreshType;
+    startedAt: number;
+    initiator: RefreshInitiator;
+    browserConnectionId?: string;
+    notifyAllBrowsers?: boolean;
+};
+declare class PendingRefreshStore {
+    private readonly pendingByDevice;
+    create(input: PendingRefresh): void;
+    get(deviceId: string): PendingRefresh | undefined;
+    has(deviceId: string): boolean;
+    remove(deviceId: string): void;
+    getExpired(now?: number): PendingRefresh[];
+}
+
+type DatabaseManifestEntry = {
+    id: string;
+    label: string;
+    relativePath: string;
+    source: 'active' | 'device';
+    deviceId?: string;
+    bundleId?: string;
+    storageKey?: string;
+    kind: string;
+    mimeType: string;
+    databaseName?: string;
+    size: number;
+    updatedAt: number;
+};
+type PersistDeviceSnapshotInput = {
+    deviceId: string;
+    bytes: Buffer;
+    kind: string;
+    mimeType: string;
+    databaseName?: string;
+    bundleId?: string;
+};
+type PersistDeviceSnapshotResult = {
+    deviceRelativePath: string;
+    exportedAt: number;
+    size: number;
+};
+
+type ProjectDatabaseMeta = {
+    exists: boolean;
+    relativePath?: string;
+    absolutePath?: string;
+    kind?: string;
+    mimeType?: string;
+    databaseName?: string;
+    size?: number;
+    updatedAt?: number;
+    source?: DatabaseManifestEntry['source'];
+    deviceId?: string;
+};
+type ListedProjectDatabase = {
+    id: string;
+    label: string;
+    relativePath: string;
+    source: DatabaseManifestEntry['source'];
+    deviceId?: string;
+    bundleId?: string;
+    storageKey?: string;
+    databaseName?: string;
+    size: number;
+    updatedAt: number;
+};
+declare class SnapshotFileStore {
+    private readonly dataDir;
+    private readonly enabled;
+    constructor(options?: {
+        dataDir?: string;
+        enabled?: boolean;
+    });
+    getDataDir(): string;
+    isEnabled(): boolean;
+    persistDeviceSnapshot(input: PersistDeviceSnapshotInput): Promise<PersistDeviceSnapshotResult | null>;
+    reconcileOnMobileConnect(input: {
+        deviceId: string;
+        bundleId?: string;
+    }): Promise<void>;
+    readDeviceSnapshot(deviceId: string): Promise<Buffer | undefined>;
+    readDeviceDatabase(deviceId: string): Promise<Buffer | undefined>;
+    getDeviceDatabaseMeta(deviceId: string): Promise<ProjectDatabaseMeta>;
+    listDeviceExports(): Promise<ListedProjectDatabase[]>;
+    private reconcileLegacyExports;
+    private pruneDeviceExports;
+    private deleteEntryFiles;
+    private manifestEntryToListed;
+    private resolveDeviceDatabaseFile;
+    /** @deprecated Proxies to the newest device export for backward-compatible API callers. */
+    readActiveDatabase(): Promise<Buffer | undefined>;
+    /** @deprecated Proxies to the newest device export for backward-compatible API callers. */
+    getActiveDatabaseMeta(): Promise<ProjectDatabaseMeta>;
+    listDatabases(): Promise<ListedProjectDatabase[]>;
+    readDatabaseByRelativePath(relativePath: string): Promise<Buffer | undefined>;
+    getDeviceDirectoryName(deviceId: string): string;
+}
+
+type StoredSnapshot = {
+    deviceId: string;
+    bytes: Buffer;
+    kind: string;
+    mimeType: string;
+    databaseName?: string;
+    exportedAt: number;
+};
+declare class SnapshotStore {
+    private readonly snapshots;
+    set(deviceId: string, bytes: Buffer, metadata: {
+        kind: string;
+        mimeType: string;
+        databaseName?: string;
+    }): StoredSnapshot;
+    get(deviceId: string): StoredSnapshot | undefined;
+    getBytes(deviceId: string): Buffer | undefined;
+}
+
+declare class RefreshCoordinator {
+    private readonly connectionManager;
+    private readonly router;
+    private readonly pending;
+    private readonly snapshots;
+    private readonly snapshotFiles?;
+    constructor(connectionManager: ConnectionManager, router: MessageRouter, pending: PendingRefreshStore, snapshots: SnapshotStore, snapshotFiles?: SnapshotFileStore | undefined);
+    handleRefreshRequest(browserSocket: WebSocket, message: RefreshRequestMessage): void;
+    handleMobileExportRequest(mobileSocket: WebSocket, message: ExportSnapshotRequestMessage): void;
+    handleSnapshotUpload(deviceId: string, body: Buffer, metadata?: {
+        kind?: string;
+        mimeType?: string;
+        databaseName?: string;
+    }): Promise<{
+        ok: true;
+        stored: SnapshotReadyMessage;
+    } | {
+        ok: false;
+        code: RefreshErrorCode;
+    }>;
+    getSnapshot(deviceId: string): Buffer | undefined;
+    getSnapshotAsync(deviceId: string): Promise<Buffer | undefined>;
+    checkTimeouts(): void;
+    private requestMobileUpload;
+    private failRefresh;
+    private failMobileExport;
+    private sendRefreshStatus;
+    private sendRefreshError;
+    private sendExportSnapshotError;
+}
+
+type WriteSession = {
+    transactionId: string;
+    deviceId: string;
+    browserConnectionId: string;
+    state: TransactionStatusState;
+    pendingWrites: number;
+    createdAt: number;
+};
+declare class WriteSessionManager {
+    private readonly sessions;
+    private readonly activeByDevice;
+    create(input: {
+        transactionId: string;
+        deviceId: string;
+        browserConnectionId: string;
+    }): WriteSession;
+    get(transactionId: string): WriteSession | undefined;
+    getActiveForDevice(deviceId: string): WriteSession | undefined;
+    setState(transactionId: string, state: TransactionStatusState): WriteSession | undefined;
+    incrementPendingWrites(transactionId: string): WriteSession | undefined;
+    decrementPendingWrites(transactionId: string): WriteSession | undefined;
+    remove(transactionId: string): void;
+    getExpired(now?: number): WriteSession[];
+    getByBrowserConnectionId(browserConnectionId: string): WriteSession[];
+    getByDeviceId(deviceId: string): WriteSession[];
+}
+
+declare class WriteCoordinator {
+    private readonly connectionManager;
+    private readonly router;
+    private readonly sessions;
+    constructor(connectionManager: ConnectionManager, router: MessageRouter, sessions: WriteSessionManager);
+    handleBeginTransactionRequest(browserSocket: WebSocket, message: BeginTransactionRequestMessage): void;
+    handleCommitTransactionRequest(browserSocket: WebSocket, message: CommitTransactionRequestMessage): void;
+    handleRollbackTransactionRequest(browserSocket: WebSocket, message: RollbackTransactionRequestMessage): void;
+    handleWriteRequest(browserSocket: WebSocket, message: WriteRequestMessage): void;
+    handleTransactionAck(message: TransactionAckMessage): void;
+    handleWriteAck(message: WriteAckMessage): void;
+    checkTimeouts(): void;
+    rollbackSessionsOnBrowserDisconnect(browserConnectionId: string): void;
+    rollbackSessionsForDevice(deviceId: string): void;
+    private rollbackSession;
+    private sendTransactionStatus;
+    private sendWriteError;
+}
+
+type DevToolsServerOptions = {
+    host?: string;
+    port?: number;
+    dataDir?: string;
+    snapshotPersistence?: boolean;
+    webDistPath?: string;
+};
+type DevToolsServerUrls = {
+    httpUrl: string;
+    wsUrl: string;
+    webUiEnabled: boolean;
+};
+type DevToolsServer = {
+    app: express.Express;
+    httpServer: Server;
+    connectionManager: ConnectionManager;
+    deviceRegistry: DeviceRegistry;
+    router: MessageRouter;
+    heartbeat: Heartbeat;
+    snapshotStore: SnapshotStore;
+    snapshotFileStore: SnapshotFileStore;
+    pendingRefreshStore: PendingRefreshStore;
+    writeSessions: WriteSessionManager;
+    refreshCoordinator: RefreshCoordinator;
+    writeCoordinator: WriteCoordinator;
+    urls: DevToolsServerUrls;
+    close: () => Promise<void>;
+};
+declare function createDevToolsServer(options?: DevToolsServerOptions): Promise<DevToolsServer>;
+
+export { type ConnectedClient as C, type DevToolsServer as D, Heartbeat as H, MessageRouter as M, type OutboundMessage as O, type PendingRefresh as P, RefreshCoordinator as R, SnapshotStore as S, ConnectionManager as a, type DevToolsServerOptions as b, DeviceRegistry as c, PendingRefreshStore as d, type StoredSnapshot as e, createDevToolsServer as f };

package/dist/createDevToolsServer-DlNMoCJR.d.ts

@@ -0,0 +1,292 @@
+import express from 'express';
+import { Server } from 'node:http';
+import { WebSocket } from 'ws';
+import { DevToolsRole, DeviceMetadata, DeviceStatusPayload, ServerMessage, RefreshType, RefreshInitiator, RefreshRequestMessage, ExportSnapshotRequestMessage, SnapshotReadyMessage, RefreshErrorCode, TransactionStatusState, BeginTransactionRequestMessage, CommitTransactionRequestMessage, RollbackTransactionRequestMessage, WriteRequestMessage, TransactionAckMessage, WriteAckMessage } from './types/protocol.js';
+
+type ConnectedClient = {
+    socket: WebSocket;
+    connectionId: string;
+    role: DevToolsRole;
+    deviceId?: string;
+    metadata?: DeviceMetadata;
+    connectedAt: number;
+    lastPongAt: number;
+};
+type RegisterClientInput = {
+    socket: WebSocket;
+    role: DevToolsRole;
+    deviceId?: string;
+    metadata?: DeviceMetadata;
+};
+declare class ConnectionManager {
+    private readonly clients;
+    add(input: RegisterClientInput): ConnectedClient;
+    remove(socket: WebSocket): ConnectedClient | undefined;
+    getBySocket(socket: WebSocket): ConnectedClient | undefined;
+    getByConnectionId(connectionId: string): ConnectedClient | undefined;
+    getByDeviceId(deviceId: string): ConnectedClient | undefined;
+    getByRole(role: DevToolsRole): ConnectedClient[];
+    updateLastPong(socket: WebSocket): void;
+    getAll(): ConnectedClient[];
+}
+
+declare class DeviceRegistry {
+    private readonly connectionManager;
+    constructor(connectionManager: ConnectionManager);
+    snapshot(): DeviceStatusPayload;
+}
+
+type OutboundMessage = ServerMessage;
+declare class MessageRouter {
+    private readonly connectionManager;
+    private readonly deviceRegistry;
+    constructor(connectionManager: ConnectionManager, deviceRegistry: DeviceRegistry);
+    sendToSocket(socket: WebSocket, message: OutboundMessage): void;
+    sendToBrowser(connectionId: string, message: OutboundMessage): void;
+    sendToMobile(deviceId: string, message: OutboundMessage): void;
+    broadcastToBrowsers(message: OutboundMessage): void;
+    broadcastToMobiles(message: OutboundMessage): void;
+    broadcastToAll(message: OutboundMessage): void;
+    broadcast(message: unknown, target?: 'browsers' | 'mobiles' | 'all'): void;
+    broadcastDeviceStatus(): void;
+}
+
+declare class Heartbeat {
+    private readonly connectionManager;
+    private readonly router;
+    private interval;
+    constructor(connectionManager: ConnectionManager, router: MessageRouter);
+    start(): void;
+    stop(): void;
+    private pingAll;
+    private removeStaleConnections;
+}
+
+type PendingRefresh = {
+    deviceId: string;
+    refreshType: RefreshType;
+    startedAt: number;
+    initiator: RefreshInitiator;
+    browserConnectionId?: string;
+    notifyAllBrowsers?: boolean;
+};
+declare class PendingRefreshStore {
+    private readonly pendingByDevice;
+    create(input: PendingRefresh): void;
+    get(deviceId: string): PendingRefresh | undefined;
+    has(deviceId: string): boolean;
+    remove(deviceId: string): void;
+    getExpired(now?: number): PendingRefresh[];
+}
+
+type DatabaseManifestEntry = {
+    id: string;
+    label: string;
+    relativePath: string;
+    source: 'active' | 'device';
+    deviceId?: string;
+    bundleId?: string;
+    storageKey?: string;
+    kind: string;
+    mimeType: string;
+    databaseName?: string;
+    size: number;
+    updatedAt: number;
+};
+type PersistDeviceSnapshotInput = {
+    deviceId: string;
+    bytes: Buffer;
+    kind: string;
+    mimeType: string;
+    databaseName?: string;
+    bundleId?: string;
+};
+type PersistDeviceSnapshotResult = {
+    deviceRelativePath: string;
+    exportedAt: number;
+    size: number;
+};
+
+type ProjectDatabaseMeta = {
+    exists: boolean;
+    relativePath?: string;
+    absolutePath?: string;
+    kind?: string;
+    mimeType?: string;
+    databaseName?: string;
+    size?: number;
+    updatedAt?: number;
+    source?: DatabaseManifestEntry['source'];
+    deviceId?: string;
+};
+type ListedProjectDatabase = {
+    id: string;
+    label: string;
+    relativePath: string;
+    source: DatabaseManifestEntry['source'];
+    deviceId?: string;
+    bundleId?: string;
+    storageKey?: string;
+    databaseName?: string;
+    size: number;
+    updatedAt: number;
+};
+declare class SnapshotFileStore {
+    private readonly dataDir;
+    private readonly enabled;
+    constructor(options?: {
+        dataDir?: string;
+        enabled?: boolean;
+    });
+    getDataDir(): string;
+    isEnabled(): boolean;
+    persistDeviceSnapshot(input: PersistDeviceSnapshotInput): Promise<PersistDeviceSnapshotResult | null>;
+    reconcileOnMobileConnect(input: {
+        deviceId: string;
+        bundleId?: string;
+    }): Promise<void>;
+    readDeviceSnapshot(deviceId: string): Promise<Buffer | undefined>;
+    readDeviceDatabase(deviceId: string): Promise<Buffer | undefined>;
+    getDeviceDatabaseMeta(deviceId: string): Promise<ProjectDatabaseMeta>;
+    listDeviceExports(): Promise<ListedProjectDatabase[]>;
+    private reconcileLegacyExports;
+    private pruneDeviceExports;
+    private deleteEntryFiles;
+    private manifestEntryToListed;
+    private resolveDeviceDatabaseFile;
+    /** @deprecated Proxies to the newest device export for backward-compatible API callers. */
+    readActiveDatabase(): Promise<Buffer | undefined>;
+    /** @deprecated Proxies to the newest device export for backward-compatible API callers. */
+    getActiveDatabaseMeta(): Promise<ProjectDatabaseMeta>;
+    listDatabases(): Promise<ListedProjectDatabase[]>;
+    readDatabaseByRelativePath(relativePath: string): Promise<Buffer | undefined>;
+    getDeviceDirectoryName(deviceId: string): string;
+}
+
+type StoredSnapshot = {
+    deviceId: string;
+    bytes: Buffer;
+    kind: string;
+    mimeType: string;
+    databaseName?: string;
+    exportedAt: number;
+};
+declare class SnapshotStore {
+    private readonly snapshots;
+    set(deviceId: string, bytes: Buffer, metadata: {
+        kind: string;
+        mimeType: string;
+        databaseName?: string;
+    }): StoredSnapshot;
+    get(deviceId: string): StoredSnapshot | undefined;
+    getBytes(deviceId: string): Buffer | undefined;
+}
+
+declare class RefreshCoordinator {
+    private readonly connectionManager;
+    private readonly router;
+    private readonly pending;
+    private readonly snapshots;
+    private readonly snapshotFiles?;
+    constructor(connectionManager: ConnectionManager, router: MessageRouter, pending: PendingRefreshStore, snapshots: SnapshotStore, snapshotFiles?: SnapshotFileStore | undefined);
+    handleRefreshRequest(browserSocket: WebSocket, message: RefreshRequestMessage): void;
+    handleMobileExportRequest(mobileSocket: WebSocket, message: ExportSnapshotRequestMessage): void;
+    handleSnapshotUpload(deviceId: string, body: Buffer, metadata?: {
+        kind?: string;
+        mimeType?: string;
+        databaseName?: string;
+    }): Promise<{
+        ok: true;
+        stored: SnapshotReadyMessage;
+    } | {
+        ok: false;
+        code: RefreshErrorCode;
+    }>;
+    getSnapshot(deviceId: string): Buffer | undefined;
+    getSnapshotAsync(deviceId: string): Promise<Buffer | undefined>;
+    checkTimeouts(): void;
+    private requestMobileUpload;
+    private failRefresh;
+    private failMobileExport;
+    private sendRefreshStatus;
+    private sendRefreshError;
+    private sendExportSnapshotError;
+}
+
+type WriteSession = {
+    transactionId: string;
+    deviceId: string;
+    browserConnectionId: string;
+    state: TransactionStatusState;
+    pendingWrites: number;
+    createdAt: number;
+};
+declare class WriteSessionManager {
+    private readonly sessions;
+    private readonly activeByDevice;
+    create(input: {
+        transactionId: string;
+        deviceId: string;
+        browserConnectionId: string;
+    }): WriteSession;
+    get(transactionId: string): WriteSession | undefined;
+    getActiveForDevice(deviceId: string): WriteSession | undefined;
+    setState(transactionId: string, state: TransactionStatusState): WriteSession | undefined;
+    incrementPendingWrites(transactionId: string): WriteSession | undefined;
+    decrementPendingWrites(transactionId: string): WriteSession | undefined;
+    remove(transactionId: string): void;
+    getExpired(now?: number): WriteSession[];
+    getByBrowserConnectionId(browserConnectionId: string): WriteSession[];
+    getByDeviceId(deviceId: string): WriteSession[];
+}
+
+declare class WriteCoordinator {
+    private readonly connectionManager;
+    private readonly router;
+    private readonly sessions;
+    constructor(connectionManager: ConnectionManager, router: MessageRouter, sessions: WriteSessionManager);
+    handleBeginTransactionRequest(browserSocket: WebSocket, message: BeginTransactionRequestMessage): void;
+    handleCommitTransactionRequest(browserSocket: WebSocket, message: CommitTransactionRequestMessage): void;
+    handleRollbackTransactionRequest(browserSocket: WebSocket, message: RollbackTransactionRequestMessage): void;
+    handleWriteRequest(browserSocket: WebSocket, message: WriteRequestMessage): void;
+    handleTransactionAck(message: TransactionAckMessage): void;
+    handleWriteAck(message: WriteAckMessage): void;
+    checkTimeouts(): void;
+    rollbackSessionsOnBrowserDisconnect(browserConnectionId: string): void;
+    rollbackSessionsForDevice(deviceId: string): void;
+    private rollbackSession;
+    private sendTransactionStatus;
+    private sendWriteError;
+}
+
+type DevToolsServerOptions = {
+    host?: string;
+    port?: number;
+    dataDir?: string;
+    snapshotPersistence?: boolean;
+    webDistPath?: string;
+};
+type DevToolsServerUrls = {
+    httpUrl: string;
+    wsUrl: string;
+    webUiEnabled: boolean;
+};
+type DevToolsServer = {
+    app: express.Express;
+    httpServer: Server;
+    connectionManager: ConnectionManager;
+    deviceRegistry: DeviceRegistry;
+    router: MessageRouter;
+    heartbeat: Heartbeat;
+    snapshotStore: SnapshotStore;
+    snapshotFileStore: SnapshotFileStore;
+    pendingRefreshStore: PendingRefreshStore;
+    writeSessions: WriteSessionManager;
+    refreshCoordinator: RefreshCoordinator;
+    writeCoordinator: WriteCoordinator;
+    urls: DevToolsServerUrls;
+    close: () => Promise<void>;
+};
+declare function createDevToolsServer(options?: DevToolsServerOptions): Promise<DevToolsServer>;
+
+export { type ConnectedClient as C, type DevToolsServer as D, Heartbeat as H, MessageRouter as M, type OutboundMessage as O, type PendingRefresh as P, RefreshCoordinator as R, SnapshotStore as S, ConnectionManager as a, type DevToolsServerOptions as b, DeviceRegistry as c, PendingRefreshStore as d, type StoredSnapshot as e, createDevToolsServer as f };

package/dist/handleDeviceSnapshot-CR-4QMdk.d.ts

@@ -0,0 +1,116 @@
+import { DeviceStatusPayload, RegisterMessage, PongMessage, RefreshRequestMessage, ExportSnapshotRequestMessage, TransactionAckMessage, WriteAckMessage, BeginTransactionRequestMessage, CommitTransactionRequestMessage, RollbackTransactionRequestMessage, WriteRequestMessage, DevToolsRole, DeviceMetadata, SnapshotUploadRequestedMessage, ExportSnapshotErrorMessage, RefreshStatusMessage, SnapshotReadyMessage, RefreshErrorMessage, BeginTransactionMessage, CommitTransactionMessage, RollbackTransactionMessage, ExecuteWriteMessage, TransactionStatusMessage, WriteResultMessage, WriteErrorMessage } from './types/protocol.js';
+import { a as WriteOperation } from './write-C3toEIMs.js';
+import { D as DatabaseAdapter } from './adapter-DJSjDewg.js';
+
+type ConnectionState = 'connecting' | 'connected' | 'reconnecting' | 'disconnected';
+type TransactionState = 'idle' | 'opening' | 'open' | 'committing' | 'rolling_back';
+type DevToolsClientOptions = {
+    serverUrl?: string;
+    role?: DevToolsRole;
+    deviceId?: string;
+    metadata?: DeviceMetadata;
+    WebSocketImpl?: typeof WebSocket;
+    onConnect?: () => void;
+    onDisconnect?: () => void;
+    onConnectionStateChange?: (state: ConnectionState) => void;
+    onDeviceStatus?: (status: DeviceStatusPayload) => void;
+    onSnapshotUploadRequested?: (message: SnapshotUploadRequestedMessage) => void;
+    onExportSnapshotError?: (message: ExportSnapshotErrorMessage) => void;
+    onRefreshStatus?: (message: RefreshStatusMessage) => void;
+    onSnapshotReady?: (message: SnapshotReadyMessage) => void;
+    onRefreshError?: (message: RefreshErrorMessage) => void;
+    onBeginTransaction?: (message: BeginTransactionMessage) => void;
+    onCommitTransaction?: (message: CommitTransactionMessage) => void;
+    onRollbackTransaction?: (message: RollbackTransactionMessage) => void;
+    onExecuteWrite?: (message: ExecuteWriteMessage) => void;
+    onTransactionStatus?: (message: TransactionStatusMessage) => void;
+    onWriteResult?: (message: WriteResultMessage) => void;
+    onWriteError?: (message: WriteErrorMessage) => void;
+    onTransactionStateChange?: (state: TransactionState) => void;
+    onError?: (error: Error) => void;
+};
+type DevToolsClient = {
+    connect: () => void;
+    disconnect: () => void;
+    getConnectionState: () => ConnectionState;
+    getLastConnectionError: () => string | null;
+    getDeviceStatus: () => DeviceStatusPayload | null;
+    getDeviceId: () => string | undefined;
+    getServerUrl: () => string;
+    setServerUrl: (url: string) => void;
+    send: (message: ClientMessageInput) => void;
+    requestRefresh: (deviceId: string) => void;
+    requestExportSnapshot: () => void;
+    sendTransactionAck: (message: Omit<TransactionAckMessage, 'timestamp' | 'type'>) => void;
+    sendWriteAck: (message: Omit<WriteAckMessage, 'timestamp' | 'type'>) => void;
+    beginTransaction: (deviceId: string) => Promise<void>;
+    commitTransaction: () => Promise<void>;
+    rollbackTransaction: () => Promise<void>;
+    executeWrite: (operation: WriteOperation) => Promise<{
+        rowsAffected: number;
+    }>;
+    getTransactionState: () => TransactionState;
+    getActiveTransactionId: () => string | null;
+};
+type ClientMessageInput = Omit<RegisterMessage, 'timestamp'> | Omit<PongMessage, 'timestamp'> | Omit<RefreshRequestMessage, 'timestamp'> | Omit<ExportSnapshotRequestMessage, 'timestamp'> | Omit<TransactionAckMessage, 'timestamp'> | Omit<WriteAckMessage, 'timestamp'> | Omit<BeginTransactionRequestMessage, 'timestamp'> | Omit<CommitTransactionRequestMessage, 'timestamp'> | Omit<RollbackTransactionRequestMessage, 'timestamp'> | Omit<WriteRequestMessage, 'timestamp'>;
+declare function createDevToolsClient(options?: DevToolsClientOptions): DevToolsClient;
+
+type ResolveProjectDatabaseUrlOptions = {
+    useSameOriginApi?: boolean;
+};
+declare function resolveProjectDatabaseUrl(serverUrl: string, options?: ResolveProjectDatabaseUrlOptions): string;
+declare function resolveProjectDatabaseMetaUrl(serverUrl: string, options?: ResolveProjectDatabaseUrlOptions): string;
+declare function resolveProjectDatabasesUrl(serverUrl: string, options?: ResolveProjectDatabaseUrlOptions): string;
+
+type ProjectDatabaseMeta = {
+    exists: boolean;
+    relativePath?: string;
+    absolutePath?: string;
+    kind?: string;
+    mimeType?: string;
+    databaseName?: string;
+    size?: number;
+    updatedAt?: number;
+    source?: 'active' | 'device';
+    deviceId?: string;
+};
+type ListedProjectDatabase = {
+    id: string;
+    label: string;
+    relativePath: string;
+    source: 'active' | 'device';
+    deviceId?: string;
+    bundleId?: string;
+    storageKey?: string;
+    databaseName?: string;
+    size: number;
+    updatedAt: number;
+};
+/** @deprecated Use device-scoped `fetchDeviceExportMeta` instead. Proxies to the newest device export. */
+declare function fetchProjectDatabaseMeta(serverUrl: string, options?: ResolveProjectDatabaseUrlOptions): Promise<ProjectDatabaseMeta>;
+/** @deprecated Use device-scoped `fetchDeviceExportDatabase` instead. Proxies to the newest device export. */
+declare function fetchProjectDatabase(serverUrl: string, options?: ResolveProjectDatabaseUrlOptions): Promise<ArrayBuffer>;
+/** @deprecated Use `fetchDeviceExports` instead. */
+declare function fetchProjectDatabases(serverUrl: string, options?: ResolveProjectDatabaseUrlOptions): Promise<ListedProjectDatabase[]>;
+
+type DeviceExportMeta = ProjectDatabaseMeta;
+type ListedDeviceExport = ListedProjectDatabase;
+declare function fetchDeviceExportMeta(serverUrl: string, deviceId: string, options?: ResolveProjectDatabaseUrlOptions): Promise<DeviceExportMeta>;
+declare function fetchDeviceExportDatabase(serverUrl: string, deviceId: string, options?: ResolveProjectDatabaseUrlOptions): Promise<ArrayBuffer>;
+declare function fetchDeviceExports(serverUrl: string, options?: ResolveProjectDatabaseUrlOptions): Promise<ListedDeviceExport[]>;
+
+declare function resolveDeviceExportDatabaseUrl(serverUrl: string, deviceId: string, options?: ResolveProjectDatabaseUrlOptions): string;
+declare function resolveDeviceExportDatabaseMetaUrl(serverUrl: string, deviceId: string, options?: ResolveProjectDatabaseUrlOptions): string;
+declare function resolveDeviceExportsUrl(serverUrl: string, options?: ResolveProjectDatabaseUrlOptions): string;
+
+declare function fetchSnapshot(downloadUrl: string): Promise<ArrayBuffer>;
+
+type HandleDeviceSnapshotOptions = {
+    /** WebSocket URL of the connected hub — used to build the upload URL on mobile. */
+    hubServerUrl?: string;
+    /** This mobile client's device ID — upload is ignored when it does not match. */
+    deviceId?: string;
+};
+declare function handleDeviceSnapshotUpload(database: DatabaseAdapter | undefined, message: SnapshotUploadRequestedMessage, options?: HandleDeviceSnapshotOptions): Promise<void>;
+
+export { type ConnectionState as C, type DevToolsClient as D, type HandleDeviceSnapshotOptions as H, type ListedDeviceExport as L, type ProjectDatabaseMeta as P, type ResolveProjectDatabaseUrlOptions as R, type TransactionState as T, type DevToolsClientOptions as a, type DeviceExportMeta as b, type ListedProjectDatabase as c, createDevToolsClient as d, fetchDeviceExportMeta as e, fetchDeviceExportDatabase as f, fetchDeviceExports as g, fetchProjectDatabase as h, fetchProjectDatabaseMeta as i, fetchProjectDatabases as j, fetchSnapshot as k, handleDeviceSnapshotUpload as l, resolveDeviceExportDatabaseUrl as m, resolveDeviceExportsUrl as n, resolveProjectDatabaseMetaUrl as o, resolveProjectDatabaseUrl as p, resolveProjectDatabasesUrl as q, resolveDeviceExportDatabaseMetaUrl as r };