@weapp-sqlite/devtools 0.0.0-stage → 0.1.0

package/dist/index.mjs

@@ -0,0 +1,423 @@
+import { c as isRecord, d as serializeDevtoolsError, f as validDatabaseNames, i as SQLITE_DEVTOOLS_SCOPE, l as isSqliteDevtoolsMethod, m as encodeSqliteDevtoolsValue, o as SqliteDevtoolsError, p as decodeSqliteDevtoolsValue, s as isIdentifier, t as SQLITE_DEVTOOLS_MAX_MESSAGE_BYTES, u as isSqliteDevtoolsWriteMethod } from "./protocol-nkWp0_XO.mjs";
+import { connectDevtoolsClient } from "./client.mjs";
+import { existsSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { DevTools } from "@vitejs/devtools";
+import { createPluginFromDevframe } from "@vitejs/devtools-kit/node";
+import { defineDevframe, defineRpcFunction } from "devframe";
+import { buildOtpAuthUrl, refreshTempAuthCode } from "devframe/node/auth";
+import { createServer } from "vite";
+import { Buffer } from "node:buffer";
+import { randomBytes, randomUUID, timingSafeEqual } from "node:crypto";
+import { WebSocket, WebSocketServer } from "ws";
+//#region src/broker.ts
+const RUNTIME_PATH = "/__weapp-sqlite/runtime";
+function errorResult(code, message) {
+	return {
+		ok: false,
+		error: {
+			code,
+			message
+		}
+	};
+}
+function validOrigin(origin) {
+	if (!origin) return true;
+	try {
+		const url = new URL(origin);
+		return [
+			"localhost",
+			"127.0.0.1",
+			"[::1]"
+		].includes(url.hostname) || url.protocol === "https:" && url.hostname === "servicewechat.com";
+	} catch {
+		return false;
+	}
+}
+function validOwnerId(value) {
+	return value === void 0 || isIdentifier(value);
+}
+/** broker 只路由到拥有数据库的 runtime，不会在 Node 端打开数据库副本。 */
+function createSqliteDevtoolsBroker(options = {}) {
+	const token = randomBytes(32).toString("hex");
+	const peers = /* @__PURE__ */ new Map();
+	const owners = /* @__PURE__ */ new Map();
+	const sockets = /* @__PURE__ */ new Set();
+	const listeners = /* @__PURE__ */ new Set();
+	const server = new WebSocketServer({
+		noServer: true,
+		maxPayload: SQLITE_DEVTOOLS_MAX_MESSAGE_BYTES,
+		perMessageDeflate: false
+	});
+	let detach;
+	let closed = false;
+	function changed() {
+		for (const listener of listeners) listener();
+	}
+	function remove(peer) {
+		for (const pending of peer.pending.values()) {
+			clearTimeout(pending.timer);
+			pending.resolve(errorResult("SQLITE_DEVTOOLS_DISCONNECTED", "Runtime disconnected. The operation was not retried; its outcome may be unknown."));
+		}
+		peer.pending.clear();
+		if (peers.get(peer.descriptor.id) === peer) {
+			peers.delete(peer.descriptor.id);
+			owners.delete(peer.descriptor.id);
+			changed();
+		}
+	}
+	server.on("connection", (socket) => {
+		if (closed || sockets.size >= 32) {
+			socket.close(1008, "Runtime capacity reached");
+			return;
+		}
+		sockets.add(socket);
+		let peer;
+		const authTimer = setTimeout(() => socket.close(1008, "Authentication timed out"), 5e3);
+		socket.on("error", () => {
+			socket.terminate();
+		});
+		socket.on("close", () => {
+			clearTimeout(authTimer);
+			sockets.delete(socket);
+			if (peer) remove(peer);
+		});
+		socket.on("message", (bytes, binary) => {
+			try {
+				const frame = Array.isArray(bytes) ? Buffer.concat(bytes) : bytes instanceof ArrayBuffer ? Buffer.from(bytes) : bytes;
+				if (binary || !peer && frame.byteLength > 32768) throw new Error("Invalid frame");
+				const message = JSON.parse(frame.toString());
+				if (!isRecord(message)) throw new Error("Invalid frame");
+				if (!peer) {
+					if (message.type !== "hello" || message.protocol !== 1 || typeof message.token !== "string" || message.token.length !== token.length || !timingSafeEqual(Buffer.from(message.token), Buffer.from(token)) || !isRecord(message.runtime) || !isIdentifier(message.runtime.id) || !isIdentifier(message.runtime.label) || !isIdentifier(message.runtime.platform) || !validDatabaseNames(message.databases)) throw new Error("Invalid authentication");
+					const old = peers.get(message.runtime.id);
+					if (old) {
+						remove(old);
+						old.socket.close(1e3, "Runtime replaced");
+					}
+					peer = {
+						socket,
+						descriptor: {
+							id: message.runtime.id,
+							label: message.runtime.label,
+							platform: message.runtime.platform,
+							databases: [...message.databases],
+							sessionId: randomUUID(),
+							connectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+							readOnly: options.allowWrite !== true
+						},
+						pending: /* @__PURE__ */ new Map()
+					};
+					clearTimeout(authTimer);
+					peers.set(peer.descriptor.id, peer);
+					socket.send(JSON.stringify({
+						type: "ready",
+						sessionId: peer.descriptor.sessionId,
+						allowWrite: options.allowWrite === true
+					}));
+					changed();
+					return;
+				}
+				if (peers.get(peer.descriptor.id) !== peer || message.sessionId !== peer.descriptor.sessionId) throw new Error("Stale runtime session");
+				if (message.type === "databases" && validDatabaseNames(message.databases)) {
+					peer = {
+						...peer,
+						descriptor: {
+							...peer.descriptor,
+							databases: [...message.databases]
+						}
+					};
+					peers.set(peer.descriptor.id, peer);
+					changed();
+					return;
+				}
+				if (message.type !== "result" && message.type !== "release-result" || !isIdentifier(message.requestId) || !isRecord(message.result)) throw new Error("Invalid runtime response");
+				const pending = peer.pending.get(message.requestId);
+				if (!pending) return;
+				const result = message.result;
+				if (result.ok === true) decodeSqliteDevtoolsValue(result.value);
+				else if (result.ok !== false || !isRecord(result.error) || !isIdentifier(result.error.code) || typeof result.error.message !== "string" || result.error.message.length > 4096) throw new Error("Invalid runtime response");
+				clearTimeout(pending.timer);
+				peer.pending.delete(message.requestId);
+				pending.resolve(result);
+			} catch {
+				socket.close(1008, "Invalid SQLite runtime protocol");
+			}
+		});
+	});
+	return {
+		token,
+		path: RUNTIME_PATH,
+		listRuntimes(ownerId) {
+			if (!validOwnerId(ownerId)) throw new SqliteDevtoolsError("SQLITE_DEVTOOLS_INVALID_REQUEST", "Invalid SQLite DevTools panel owner.");
+			if (ownerId) for (const runtime of peers.values()) {
+				const runtimeOwners = owners.get(runtime.descriptor.id) ?? /* @__PURE__ */ new Set();
+				runtimeOwners.add(ownerId);
+				owners.set(runtime.descriptor.id, runtimeOwners);
+			}
+			return [...peers.values()].map((peer) => ({
+				...peer.descriptor,
+				databases: [...peer.descriptor.databases]
+			}));
+		},
+		subscribe(listener) {
+			listeners.add(listener);
+			return () => {
+				listeners.delete(listener);
+			};
+		},
+		async invoke(input) {
+			try {
+				if (!isRecord(input) || !isIdentifier(input.runtimeId) || !isIdentifier(input.sessionId) || !isIdentifier(input.databaseName) || !isSqliteDevtoolsMethod(input.method) || input.method === "close") throw new SqliteDevtoolsError("SQLITE_DEVTOOLS_INVALID_REQUEST", "Unknown SQLite runtime, database, or method.");
+				const args = decodeSqliteDevtoolsValue(input.args);
+				if (!Array.isArray(args) || args.length > 8) throw new SqliteDevtoolsError("SQLITE_DEVTOOLS_INVALID_REQUEST", "SQLite arguments must be an array.");
+				const peer = peers.get(input.runtimeId);
+				if (!peer || peer.descriptor.sessionId !== input.sessionId || peer.socket.readyState !== WebSocket.OPEN) return errorResult("SQLITE_DEVTOOLS_DISCONNECTED", "The selected runtime session is no longer connected.");
+				if (!peer.descriptor.databases.includes(input.databaseName)) return errorResult("SQLITE_DEVTOOLS_DATABASE_CLOSED", "The selected database is no longer registered.");
+				if (options.allowWrite !== true && isSqliteDevtoolsWriteMethod(input.method)) return errorResult("SQLITE_DEVTOOLS_READ_ONLY", "This SQLite DevTools host is read-only.");
+				if (peer.pending.size >= 64) return errorResult("SQLITE_DEVTOOLS_BUSY", "Too many pending SQLite operations.");
+				const requestId = randomUUID();
+				const frame = JSON.stringify({
+					...input,
+					type: "request",
+					requestId
+				});
+				if (Buffer.byteLength(frame) > 16777216) return errorResult("SQLITE_DEVTOOLS_PAYLOAD_LIMIT", "SQLite operation exceeds the message limit.");
+				return await new Promise((resolve) => {
+					const timer = setTimeout(() => {
+						peer.pending.delete(requestId);
+						resolve(errorResult("SQLITE_DEVTOOLS_TIMEOUT", "SQLite operation timed out. It was not retried; its outcome may be unknown."));
+					}, options.requestTimeoutMs ?? 3e4);
+					peer.pending.set(requestId, {
+						resolve,
+						timer
+					});
+					peer.socket.send(frame, (error) => {
+						if (error) {
+							remove(peer);
+							peer.socket.terminate();
+						}
+					});
+				});
+			} catch (error) {
+				return {
+					ok: false,
+					error: serializeDevtoolsError(error)
+				};
+			}
+		},
+		async releaseSession(input) {
+			try {
+				if (!isRecord(input) || !isIdentifier(input.runtimeId) || !isIdentifier(input.sessionId) || !validOwnerId(input.ownerId)) throw new SqliteDevtoolsError("SQLITE_DEVTOOLS_INVALID_REQUEST", "Unknown SQLite runtime session.");
+				const ownerId = input.ownerId;
+				if (ownerId) {
+					const runtimeOwners = owners.get(input.runtimeId);
+					if (!runtimeOwners?.has(ownerId)) return {
+						ok: true,
+						value: encodeSqliteDevtoolsValue(void 0)
+					};
+					runtimeOwners.delete(ownerId);
+					if (runtimeOwners.size > 0) return {
+						ok: true,
+						value: encodeSqliteDevtoolsValue(void 0)
+					};
+					owners.delete(input.runtimeId);
+				}
+				const peer = peers.get(input.runtimeId);
+				if (!peer || peer.descriptor.sessionId !== input.sessionId || peer.socket.readyState !== WebSocket.OPEN) return errorResult("SQLITE_DEVTOOLS_DISCONNECTED", "The selected runtime session is no longer connected.");
+				if (peer.pending.size >= 64) return errorResult("SQLITE_DEVTOOLS_BUSY", "Too many pending SQLite operations.");
+				const requestId = randomUUID();
+				const frame = JSON.stringify({
+					type: "release",
+					sessionId: peer.descriptor.sessionId,
+					requestId
+				});
+				if (Buffer.byteLength(frame) > 16777216) return errorResult("SQLITE_DEVTOOLS_PAYLOAD_LIMIT", "SQLite session release exceeds the message limit.");
+				return await new Promise((resolve) => {
+					const timer = setTimeout(() => {
+						peer.pending.delete(requestId);
+						resolve(errorResult("SQLITE_DEVTOOLS_TIMEOUT", "SQLite debug session release timed out."));
+					}, options.requestTimeoutMs ?? 3e4);
+					peer.pending.set(requestId, {
+						resolve,
+						timer
+					});
+					peer.socket.send(frame, (error) => {
+						if (error) {
+							remove(peer);
+							peer.socket.terminate();
+						}
+					});
+				});
+			} catch (error) {
+				return {
+					ok: false,
+					error: serializeDevtoolsError(error)
+				};
+			}
+		},
+		attach(httpServer) {
+			if (closed || detach) throw new Error("SQLite runtime broker is already attached or closed.");
+			const upgrade = (request, socket, head) => {
+				if (request.url?.split("?")[0] !== RUNTIME_PATH) return;
+				if (closed || !validOrigin(request.headers.origin)) {
+					socket.destroy();
+					return;
+				}
+				server.handleUpgrade(request, socket, head, (client) => {
+					server.emit("connection", client, request);
+				});
+			};
+			httpServer.on("upgrade", upgrade);
+			detach = () => {
+				httpServer.off("upgrade", upgrade);
+			};
+		},
+		async close() {
+			if (closed) return;
+			closed = true;
+			detach?.();
+			for (const peer of peers.values()) remove(peer);
+			for (const socket of sockets) socket.terminate();
+			await new Promise((resolve) => {
+				server.close(() => resolve());
+			});
+			listeners.clear();
+		}
+	};
+}
+//#endregion
+//#region src/index.ts
+function createSqliteDevtoolsDevframe(options = {}) {
+	const broker = createSqliteDevtoolsBroker(options);
+	let unsubscribe;
+	let disposing;
+	return {
+		definition: defineDevframe({
+			id: SQLITE_DEVTOOLS_SCOPE,
+			name: "SQLite",
+			version: "0.1.0",
+			packageName: "@weapp-sqlite/devtools",
+			importMetaUrl: import.meta.url,
+			homepage: "https://github.com/weapp-sqlite/weapp-sqlite",
+			description: "查看与调试 Web 和小程序运行时中的 SQLite 数据库。",
+			icon: "ph:database-duotone",
+			capabilities: {
+				dev: true,
+				build: false
+			},
+			clientAssets: options.clientAssets ?? fileURLToPath(new URL("./client/", import.meta.url)),
+			async setup(ctx) {
+				const scope = ctx.scope(SQLITE_DEVTOOLS_SCOPE);
+				scope.rpc.register(defineRpcFunction({
+					name: "list-runtimes",
+					type: "query",
+					jsonSerializable: true,
+					handler: broker.listRuntimes
+				}));
+				scope.rpc.register(defineRpcFunction({
+					name: "invoke",
+					type: "action",
+					jsonSerializable: true,
+					handler: broker.invoke
+				}));
+				scope.rpc.register(defineRpcFunction({
+					name: "release-session",
+					type: "action",
+					jsonSerializable: true,
+					handler: broker.releaseSession
+				}));
+				unsubscribe?.();
+				unsubscribe = broker.subscribe(() => {
+					scope.rpc.broadcast({
+						method: "state-updated",
+						args: [broker.listRuntimes()],
+						event: true
+					}).catch(() => {});
+				});
+			}
+		}),
+		broker,
+		dispose() {
+			return disposing ??= (async () => {
+				unsubscribe?.();
+				unsubscribe = void 0;
+				await broker.close();
+			})();
+		}
+	};
+}
+function createSqliteDevtoolsPlugin(controller) {
+	return {
+		...createPluginFromDevframe(controller.definition),
+		apply: "serve",
+		configureServer(server) {
+			if (!server.httpServer) throw new Error("SQLite DevTools requires an HTTP server for its runtime bridge.");
+			controller.broker.attach(server.httpServer);
+			server.httpServer.once("close", () => {
+				controller.dispose();
+			});
+		},
+		async closeServer() {
+			await controller.dispose();
+		},
+		async closeBundle() {
+			await controller.dispose();
+		}
+	};
+}
+/** 创建独立开发宿主；调用方负责其 watcher 与退出生命周期。 */
+async function startSqliteDevtoolsServer(options = {}) {
+	const controller = createSqliteDevtoolsDevframe(options);
+	const assets = controller.definition.clientAssets;
+	if (typeof assets !== "string" || !existsSync(path.join(assets, "index.html"))) {
+		await controller.dispose();
+		throw new Error("SQLite DevTools client is missing. Build @weapp-sqlite/devtools first.");
+	}
+	let server;
+	try {
+		const devtoolsPlugins = await DevTools({
+			builtinDevTools: false,
+			clientAuth: true,
+			allowedOrigins: [],
+			mcp: false
+		});
+		server = await createServer({
+			configFile: false,
+			root: options.cwd ?? process.cwd(),
+			publicDir: false,
+			appType: "custom",
+			clearScreen: false,
+			logLevel: "silent",
+			plugins: [...devtoolsPlugins, createSqliteDevtoolsPlugin(controller)],
+			server: {
+				host: "127.0.0.1",
+				port: options.port ?? 0,
+				strictPort: options.port !== void 0 && options.port !== 0,
+				watch: { ignored: ["**/*"] }
+			}
+		});
+		await server.listen();
+		const address = server.httpServer?.address();
+		if (!address || typeof address === "string") throw new Error("SQLite DevTools could not resolve its listening port.");
+		const origin = `http://127.0.0.1:${address.port}`;
+		let closing;
+		const activeServer = server;
+		return {
+			url: buildOtpAuthUrl(`${origin}/__weapp-sqlite/`, refreshTempAuthCode()),
+			runtimeEndpoint: `ws://127.0.0.1:${address.port}${controller.broker.path}`,
+			runtimeToken: controller.broker.token,
+			close() {
+				return closing ??= controller.dispose().finally(() => activeServer.close());
+			}
+		};
+	} catch (error) {
+		await controller.dispose();
+		await server?.close();
+		throw error;
+	}
+}
+//#endregion
+export { connectDevtoolsClient, createSqliteDevtoolsDevframe, createSqliteDevtoolsPlugin, startSqliteDevtoolsServer };

package/dist/protocol-BhfjLrSe.d.cts

@@ -0,0 +1,76 @@
+//#region src/codec.d.ts
+/** 使用显式标签保留整数和二进制值，普通对象不能伪装成协议标签。 */
+declare function encodeSqliteDevtoolsValue(value: unknown, maxBytes?: number): SqliteDevtoolsWireValue;
+declare function decodeSqliteDevtoolsValue(value: unknown, maxBytes?: number): unknown;
+//#endregion
+//#region src/protocol.d.ts
+declare const SQLITE_DEVTOOLS_SCOPE = "weapp-sqlite";
+declare const SQLITE_DEVTOOLS_PROTOCOL = 1;
+declare const SQLITE_DEVTOOLS_MAX_MESSAGE_BYTES: number;
+declare const SQLITE_DEVTOOLS_READ_METHODS: readonly ["listTables", "describeTable", "getTableCapabilities", "listIndexes", "readTable", "query", "analyzeQuery", "getMigrationStatus", "getMigrationDiagnostics", "getForeignKeyDiagnostics", "exportDatabase", "exportTable", "previewTableImport", "getUndoState"];
+declare const SQLITE_DEVTOOLS_WRITE_METHODS: readonly ["execute", "insertRow", "updateRow", "deleteRows", "createTable", "renameTable", "dropTable", "truncateTable", "addColumn", "renameColumn", "dropColumn", "createIndex", "dropIndex", "importDatabase", "importTable", "undoLastDestructiveChange", "resetDatabase"];
+type SqliteDevtoolsMethod = typeof SQLITE_DEVTOOLS_READ_METHODS[number] | typeof SQLITE_DEVTOOLS_WRITE_METHODS[number] | 'close';
+interface SqliteDevtoolsRuntime {
+  readonly id: string;
+  readonly label: string;
+  readonly platform: string;
+}
+interface SqliteDevtoolsRuntimeDescriptor extends SqliteDevtoolsRuntime {
+  readonly databases: readonly string[];
+  readonly sessionId: string;
+  readonly connectedAt: string;
+  readonly readOnly: boolean;
+}
+interface SqliteDevtoolsErrorData {
+  readonly code: string;
+  readonly message: string;
+}
+declare class SqliteDevtoolsError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+type SqliteDevtoolsWireValue = null | boolean | number | string | {
+  readonly type: 'undefined';
+} | {
+  readonly type: 'bigint';
+  readonly value: string;
+} | {
+  readonly type: 'bytes';
+  readonly value: string;
+  readonly kind: 'uint8array' | 'arraybuffer';
+} | {
+  readonly type: 'array';
+  readonly value: readonly SqliteDevtoolsWireValue[];
+} | {
+  readonly type: 'object';
+  readonly value: readonly (readonly [string, SqliteDevtoolsWireValue])[];
+};
+type SqliteDevtoolsResult = {
+  readonly ok: true;
+  readonly value: SqliteDevtoolsWireValue;
+} | {
+  readonly ok: false;
+  readonly error: SqliteDevtoolsErrorData;
+};
+interface SqliteDevtoolsInvocation {
+  readonly runtimeId: string;
+  readonly sessionId: string;
+  readonly databaseName: string;
+  readonly method: SqliteDevtoolsMethod;
+  readonly args: SqliteDevtoolsWireValue;
+}
+/** Releases only the debug controllers owned by a panel session. */
+interface SqliteDevtoolsReleaseSession {
+  readonly runtimeId: string;
+  readonly sessionId: string;
+  /** Stable id for one Devframe panel connection. */
+  readonly ownerId?: string;
+}
+declare function isSqliteDevtoolsMethod(value: unknown): value is SqliteDevtoolsMethod;
+declare function isSqliteDevtoolsWriteMethod(value: SqliteDevtoolsMethod): boolean;
+declare function isIdentifier(value: unknown): value is string;
+declare function serializeDevtoolsError(error: unknown): SqliteDevtoolsErrorData;
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+declare function validDatabaseNames(value: unknown): value is string[];
+//#endregion
+export { encodeSqliteDevtoolsValue as S, isSqliteDevtoolsMethod as _, SQLITE_DEVTOOLS_WRITE_METHODS as a, validDatabaseNames as b, SqliteDevtoolsInvocation as c, SqliteDevtoolsResult as d, SqliteDevtoolsRuntime as f, isRecord as g, isIdentifier as h, SQLITE_DEVTOOLS_SCOPE as i, SqliteDevtoolsMethod as l, SqliteDevtoolsWireValue as m, SQLITE_DEVTOOLS_PROTOCOL as n, SqliteDevtoolsError as o, SqliteDevtoolsRuntimeDescriptor as p, SQLITE_DEVTOOLS_READ_METHODS as r, SqliteDevtoolsErrorData as s, SQLITE_DEVTOOLS_MAX_MESSAGE_BYTES as t, SqliteDevtoolsReleaseSession as u, isSqliteDevtoolsWriteMethod as v, decodeSqliteDevtoolsValue as x, serializeDevtoolsError as y };

package/dist/protocol-BhfjLrSe.d.mts

@@ -0,0 +1,76 @@
+//#region src/codec.d.ts
+/** 使用显式标签保留整数和二进制值，普通对象不能伪装成协议标签。 */
+declare function encodeSqliteDevtoolsValue(value: unknown, maxBytes?: number): SqliteDevtoolsWireValue;
+declare function decodeSqliteDevtoolsValue(value: unknown, maxBytes?: number): unknown;
+//#endregion
+//#region src/protocol.d.ts
+declare const SQLITE_DEVTOOLS_SCOPE = "weapp-sqlite";
+declare const SQLITE_DEVTOOLS_PROTOCOL = 1;
+declare const SQLITE_DEVTOOLS_MAX_MESSAGE_BYTES: number;
+declare const SQLITE_DEVTOOLS_READ_METHODS: readonly ["listTables", "describeTable", "getTableCapabilities", "listIndexes", "readTable", "query", "analyzeQuery", "getMigrationStatus", "getMigrationDiagnostics", "getForeignKeyDiagnostics", "exportDatabase", "exportTable", "previewTableImport", "getUndoState"];
+declare const SQLITE_DEVTOOLS_WRITE_METHODS: readonly ["execute", "insertRow", "updateRow", "deleteRows", "createTable", "renameTable", "dropTable", "truncateTable", "addColumn", "renameColumn", "dropColumn", "createIndex", "dropIndex", "importDatabase", "importTable", "undoLastDestructiveChange", "resetDatabase"];
+type SqliteDevtoolsMethod = typeof SQLITE_DEVTOOLS_READ_METHODS[number] | typeof SQLITE_DEVTOOLS_WRITE_METHODS[number] | 'close';
+interface SqliteDevtoolsRuntime {
+  readonly id: string;
+  readonly label: string;
+  readonly platform: string;
+}
+interface SqliteDevtoolsRuntimeDescriptor extends SqliteDevtoolsRuntime {
+  readonly databases: readonly string[];
+  readonly sessionId: string;
+  readonly connectedAt: string;
+  readonly readOnly: boolean;
+}
+interface SqliteDevtoolsErrorData {
+  readonly code: string;
+  readonly message: string;
+}
+declare class SqliteDevtoolsError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
+type SqliteDevtoolsWireValue = null | boolean | number | string | {
+  readonly type: 'undefined';
+} | {
+  readonly type: 'bigint';
+  readonly value: string;
+} | {
+  readonly type: 'bytes';
+  readonly value: string;
+  readonly kind: 'uint8array' | 'arraybuffer';
+} | {
+  readonly type: 'array';
+  readonly value: readonly SqliteDevtoolsWireValue[];
+} | {
+  readonly type: 'object';
+  readonly value: readonly (readonly [string, SqliteDevtoolsWireValue])[];
+};
+type SqliteDevtoolsResult = {
+  readonly ok: true;
+  readonly value: SqliteDevtoolsWireValue;
+} | {
+  readonly ok: false;
+  readonly error: SqliteDevtoolsErrorData;
+};
+interface SqliteDevtoolsInvocation {
+  readonly runtimeId: string;
+  readonly sessionId: string;
+  readonly databaseName: string;
+  readonly method: SqliteDevtoolsMethod;
+  readonly args: SqliteDevtoolsWireValue;
+}
+/** Releases only the debug controllers owned by a panel session. */
+interface SqliteDevtoolsReleaseSession {
+  readonly runtimeId: string;
+  readonly sessionId: string;
+  /** Stable id for one Devframe panel connection. */
+  readonly ownerId?: string;
+}
+declare function isSqliteDevtoolsMethod(value: unknown): value is SqliteDevtoolsMethod;
+declare function isSqliteDevtoolsWriteMethod(value: SqliteDevtoolsMethod): boolean;
+declare function isIdentifier(value: unknown): value is string;
+declare function serializeDevtoolsError(error: unknown): SqliteDevtoolsErrorData;
+declare function isRecord(value: unknown): value is Record<string, unknown>;
+declare function validDatabaseNames(value: unknown): value is string[];
+//#endregion
+export { encodeSqliteDevtoolsValue as S, isSqliteDevtoolsMethod as _, SQLITE_DEVTOOLS_WRITE_METHODS as a, validDatabaseNames as b, SqliteDevtoolsInvocation as c, SqliteDevtoolsResult as d, SqliteDevtoolsRuntime as f, isRecord as g, isIdentifier as h, SQLITE_DEVTOOLS_SCOPE as i, SqliteDevtoolsMethod as l, SqliteDevtoolsWireValue as m, SQLITE_DEVTOOLS_PROTOCOL as n, SqliteDevtoolsError as o, SqliteDevtoolsRuntimeDescriptor as p, SQLITE_DEVTOOLS_READ_METHODS as r, SqliteDevtoolsErrorData as s, SQLITE_DEVTOOLS_MAX_MESSAGE_BYTES as t, SqliteDevtoolsReleaseSession as u, isSqliteDevtoolsWriteMethod as v, decodeSqliteDevtoolsValue as x, serializeDevtoolsError as y };