qubu 0.6.0 → 0.6.2

package/dist/introspection/sqlite.mjs

@@ -0,0 +1,1172 @@
+import { n as createIntrospectionDiagnostic } from "../diagnostics-I9vVtXkc.mjs";
+//#region src/introspection/sqlite.ts
+const sqliteServerQuery = `SELECT sqlite_version() AS version, sqlite_source_id() AS source_id`;
+const sqliteDatabaseListQuery = `
+  SELECT seq, name, file
+  FROM pragma_database_list()
+  ORDER BY seq
+`;
+const sqliteSchemaQuery = `
+  SELECT type, name, tbl_name, sql
+  FROM main.sqlite_schema
+  WHERE name NOT LIKE 'sqlite_%'
+  ORDER BY type, name
+`;
+const sqliteTempSchemaQuery = `
+  SELECT type, name, tbl_name, sql
+  FROM temp.sqlite_schema
+  WHERE name NOT LIKE 'sqlite_%'
+  ORDER BY type, name
+`;
+const sqliteTableListQuery = `
+  SELECT schema, name, type, ncol, wr, strict
+  FROM pragma_table_list
+  WHERE schema = ? AND name NOT LIKE 'sqlite_%'
+  ORDER BY name
+`;
+const sqliteTableInfoQuery = `
+  SELECT cid, name, type, "notnull" AS not_null, dflt_value, pk, hidden
+  FROM pragma_table_xinfo(?, ?)
+  ORDER BY cid
+`;
+const sqliteIndexListQuery = `
+  SELECT seq, name, "unique" AS unique_index, origin, partial
+  FROM pragma_index_list(?, ?)
+  ORDER BY seq
+`;
+const sqliteIndexInfoQuery = `
+  SELECT seqno, cid, name, "desc" AS descending, coll, key
+  FROM pragma_index_xinfo(?, ?)
+  ORDER BY seqno
+`;
+const sqliteForeignKeyQuery = `
+  SELECT id, seq, "table" AS target_table, "from" AS source_column,
+         "to" AS target_column, on_update, on_delete, match
+  FROM pragma_foreign_key_list(?, ?)
+  ORDER BY id, seq
+`;
+/** Read the selected SQLite database namespace into the normalized catalog. */
+async function readCatalog(connection, options) {
+	const diagnostics = [];
+	if (connection.dialect !== "sqlite") {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "dialect-mismatch",
+			message: "SQLite catalog reading requires a SQLite CatalogConnection",
+			path: ["connection", "dialect"]
+		}));
+		return emptyCatalog(options.namespace, diagnostics);
+	}
+	const serverRows = await query(connection, sqliteServerQuery, [], options, diagnostics, "server");
+	const server = serverInfo(serverRows[0], diagnostics);
+	const databaseRows = await query(connection, sqliteDatabaseListQuery, [], options, diagnostics, "database-list");
+	const databaseNames = databaseRows.map((row) => text(row.name)).filter((name) => name !== void 0);
+	if (databaseNames.length > 0 && !databaseNames.includes(options.namespace)) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "error",
+		code: "missing-catalog-row",
+		message: `SQLite database ${options.namespace} is not attached to the selected connection`,
+		path: ["namespace", options.namespace],
+		remediation: "Attach the database before starting introspection."
+	}));
+	const schemaRows = options.namespace === "main" || options.namespace === "temp" ? await query(connection, options.namespace === "temp" ? sqliteTempSchemaQuery : sqliteSchemaQuery, [], options, diagnostics, "schema") : [];
+	if (options.namespace !== "main" && options.namespace !== "temp" && databaseNames.includes(options.namespace)) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "partial-result",
+		message: `SQLite attached database ${options.namespace} exposes table PRAGMAs but its schema SQL is outside the fixed main/temp catalog statements`,
+		path: [
+			"namespace",
+			options.namespace,
+			"schema"
+		],
+		remediation: "Use a driver adapter that exposes the attached schema through a fixed statement before relying on generated SQL."
+	}));
+	const tableRows = await query(connection, sqliteTableListQuery, [options.namespace], options, diagnostics, "table-list");
+	const tableSql = new Map(schemaRows.map((row) => [text(row.name), text(row.sql)]).filter((entry) => entry[0] !== void 0));
+	const tables = tableRows.filter((row) => normalizeType(row.type) === "table").map((row) => table(row, tableSql.get(text(row.name) ?? "") ?? void 0, options.namespace));
+	const tableByName = new Map(tables.map((currentTable) => [currentTable.physicalName, currentTable]));
+	const deferredObjects = [];
+	const opaqueObjects = [];
+	for (const row of tableRows) {
+		const type = normalizeType(row.type);
+		if (type !== "virtual" && type !== "shadow") continue;
+		const physicalName = text(row.name) ?? "unnamed_object";
+		deferredObjects.push(deferred(type === "virtual" ? "virtual-table" : "shadow-table", physicalName, tableSql.get(physicalName), options.namespace));
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "warning",
+			code: "unmodeled-object",
+			message: `SQLite ${type} table ${physicalName} is retained as a deferred object`,
+			path: ["deferredObjects", physicalName],
+			physicalReference: reference("deferred-object", physicalName, options.namespace, "pragma_table_list", "name"),
+			remediation: "Inspect the deferred record before using it as migration input."
+		}));
+	}
+	for (const row of databaseRows) {
+		const name = text(row.name);
+		if (!name || name === options.namespace || name === "main" || name === "temp") continue;
+		const boundary = attachedDatabaseObject(row, options.namespace);
+		opaqueObjects.push(boundary);
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "info",
+			code: "partial-result",
+			message: `Attached SQLite database ${name} is outside the selected namespace`,
+			path: [
+				"namespace",
+				"attached",
+				name
+			],
+			physicalReference: boundary.reference,
+			remediation: "Run a separate catalog read with this database name to inspect it."
+		}));
+	}
+	const views = [];
+	for (const row of tableRows.filter((row) => normalizeType(row.type) === "view")) {
+		const physicalName = text(row.name) ?? "unnamed_view";
+		const view = mapView(row, tableSql.get(physicalName), options.namespace, diagnostics);
+		if (view.kind === "deferred-object") deferredObjects.push(view);
+		else views.push(view);
+	}
+	const relationReferences = /* @__PURE__ */ new Map();
+	for (const table of tables) relationReferences.set(table.physicalName, {
+		kind: "table",
+		id: table.id
+	});
+	for (const view of views) relationReferences.set(view.physicalName, {
+		kind: view.kind,
+		id: view.id
+	});
+	const triggers = [];
+	for (const currentTable of tables) {
+		const tableName = currentTable.physicalName;
+		const rows = await query(connection, sqliteTableInfoQuery, [tableName, options.namespace], options, diagnostics, `table-xinfo:${tableName}`);
+		const sqlText = tableSql.get(tableName);
+		const rowidPrimaryKey = rows.filter((row) => (number(row.pk) ?? 0) > 0).length === 1;
+		const columns = rows.filter((row) => number(row.hidden) !== 1).map((row) => column(row, currentTable, options.namespace, sqlText, rowidPrimaryKey, diagnostics));
+		currentTable.columns = columns;
+		currentTable.constraints = tableConstraints(currentTable, rows, columns, sqlText, options.namespace, diagnostics, opaqueObjects);
+	}
+	for (const currentTable of tables) {
+		const tableName = currentTable.physicalName;
+		const sqlText = tableSql.get(tableName);
+		const indexRows = await query(connection, sqliteIndexListQuery, [tableName, options.namespace], options, diagnostics, `index-list:${tableName}`);
+		const mappedIndexes = [];
+		const mappedConstraints = [...currentTable.constraints];
+		for (const indexRow of indexRows) {
+			const indexName = text(indexRow.name);
+			if (!indexName || indexName.startsWith("sqlite_autoindex_") && text(indexRow.origin)?.toLowerCase() !== "u") continue;
+			const index = mapIndex(currentTable, indexRow, await query(connection, sqliteIndexInfoQuery, [indexName, options.namespace], options, diagnostics, `index-info:${indexName}`), text(indexRow.origin)?.toLowerCase() === "u" ? sqlText : tableSql.get(indexName), options.namespace, diagnostics, opaqueObjects);
+			if (!index) continue;
+			if (index.kind === "index") mappedIndexes.push(index);
+			else mappedConstraints.push(index);
+		}
+		const foreignRows = await query(connection, sqliteForeignKeyQuery, [tableName, options.namespace], options, diagnostics, `foreign-key:${tableName}`);
+		for (const value of foreignKeys(currentTable, foreignRows, tableByName, options.namespace, diagnostics)) if (value.kind === "opaque-object") opaqueObjects.push(value);
+		else mappedConstraints.push(value);
+		currentTable.indexes = mappedIndexes;
+		currentTable.constraints = mappedConstraints;
+	}
+	for (const view of views) view.columns = (await query(connection, sqliteTableInfoQuery, [view.physicalName, options.namespace], options, diagnostics, `view-xinfo:${view.physicalName}`)).filter((row) => number(row.hidden) !== 1).map((row) => column(row, view, options.namespace, void 0, false, diagnostics));
+	for (const row of schemaRows.filter((row) => normalizeType(row.type) === "trigger")) {
+		const trigger = mapTrigger(row, options.namespace, relationReferences, diagnostics);
+		if (trigger.kind === "deferred-object") deferredObjects.push(trigger);
+		else triggers.push(trigger);
+	}
+	for (const row of schemaRows) {
+		const type = normalizeType(row.type);
+		if (type === "table" || type === "view" || type === "trigger" || type === "index") continue;
+		const physicalName = text(row.name) ?? "unnamed_object";
+		opaqueObjects.push(opaqueSchemaObject(row, options.namespace, diagnostics));
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "warning",
+			code: "unmodeled-object",
+			message: `SQLite schema object ${physicalName} (${type || "unknown"}) is retained as opaque data`,
+			path: ["opaqueObjects", physicalName],
+			physicalReference: reference("opaque-object", physicalName, options.namespace, "sqlite_schema", "name")
+		}));
+	}
+	const visibility = databaseRows.length > 0 && options.namespace !== "main" && options.namespace !== "temp" ? "limited" : server.capabilities.visibility;
+	const capabilities = {
+		generatedColumns: server.capabilities.generatedColumns,
+		identityMetadata: server.capabilities.identityMetadata,
+		checkConstraints: server.capabilities.checkConstraints,
+		checkConstraintEnforcement: server.capabilities.checkConstraintEnforcement,
+		expressionDecompilation: server.capabilities.expressionDecompilation,
+		indexExpressions: server.capabilities.indexExpressions,
+		indexPredicates: server.capabilities.indexPredicates,
+		indexIncludedColumns: server.capabilities.indexIncludedColumns,
+		namespaces: server.capabilities.namespaces,
+		visibility
+	};
+	const serverCapabilities = {
+		...server.capabilities,
+		attachedDatabases: true,
+		views: true,
+		triggers: true,
+		virtualTables: true,
+		shadowTables: true,
+		comments: false,
+		ownership: false,
+		typedExtensions: true,
+		affinityFacts: true,
+		generatedSql: true,
+		selectedNamespace: options.namespace,
+		visibility
+	};
+	return Object.freeze({
+		dialect: "sqlite",
+		server: {
+			...server,
+			capabilities: serverCapabilities
+		},
+		namespace: {
+			kind: "sqlite-database",
+			name: options.namespace,
+			reference: reference("namespace", options.namespace, options.namespace, "sqlite_schema", "name"),
+			dialect: extension({
+				selectedNamespace: options.namespace,
+				sourceIdAvailable: serverSourceIdAvailable(serverRows[0]),
+				views: true,
+				triggers: true,
+				virtualTables: true,
+				shadowTables: true,
+				comments: false,
+				ownership: false,
+				typedExtensions: true,
+				affinityFacts: true,
+				generatedSql: true,
+				visibility,
+				attachedDatabases: databaseNames.filter((name) => name !== options.namespace)
+			})
+		},
+		tables: Object.freeze(tables),
+		views: Object.freeze(views),
+		triggers: Object.freeze(triggers),
+		deferredObjects: Object.freeze(deferredObjects),
+		opaqueObjects: Object.freeze(opaqueObjects),
+		capabilities,
+		diagnostics: Object.freeze(diagnostics)
+	});
+}
+async function query(connection, textValue, parameters, options, diagnostics, operation) {
+	try {
+		return await connection.query({
+			text: textValue,
+			parameters
+		}, { signal: options.signal });
+	} catch {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "query-failed",
+			message: `SQLite catalog query failed while reading ${operation}`,
+			path: [operation],
+			remediation: "Check SQLite metadata visibility and the selected database."
+		}));
+		return [];
+	}
+}
+function serverInfo(row, diagnostics) {
+	const rawVersion = text(row?.version) ?? "unknown";
+	const parts = rawVersion.split(".").map((item) => Number(item));
+	const supported = parts.length >= 2 && parts[0] === 3 && parts[1] >= 37;
+	if (!supported) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "error",
+		code: "unsupported-server",
+		message: "SQLite introspection requires SQLite 3.37 or newer",
+		path: ["server", "version"],
+		remediation: "Use SQLite 3.37+ or provide a compatible adapter capability set."
+	}));
+	return {
+		product: "sqlite",
+		rawVersion,
+		parsedVersion: Number.isFinite(parts[0]) ? {
+			major: parts[0],
+			minor: parts[1],
+			patch: parts[2]
+		} : void 0,
+		capabilities: {
+			generatedColumns: supported,
+			identityMetadata: true,
+			checkConstraints: true,
+			checkConstraintEnforcement: "enforced",
+			expressionDecompilation: false,
+			indexExpressions: true,
+			indexPredicates: true,
+			indexIncludedColumns: false,
+			namespaces: false,
+			visibility: "complete",
+			sourceIdAvailable: text(row?.source_id) !== void 0
+		}
+	};
+}
+function serverSourceIdAvailable(row) {
+	return text(row?.source_id) !== void 0;
+}
+function normalizeType(value) {
+	return text(value)?.trim().toLowerCase() ?? "";
+}
+function mapView(row, sqlText, namespace, diagnostics) {
+	const physicalName = text(row.name) ?? "unnamed_view";
+	const physicalReference = reference("view", physicalName, namespace, "sqlite_schema", "name");
+	const definition = viewDefinition(sqlText);
+	if (!definition) {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "expression-parse-failed",
+			message: `SQLite view ${physicalName} has no recoverable SELECT definition`,
+			path: [
+				"views",
+				physicalName,
+				"definition"
+			],
+			physicalReference,
+			remediation: "Preserve the CREATE VIEW SQL returned by sqlite_schema."
+		}));
+		return deferred("view", physicalName, sqlText, namespace);
+	}
+	return {
+		kind: "view",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		columns: [],
+		definition: sql(definition, namespace, {
+			kind: "view",
+			physicalName,
+			reference: physicalReference
+		}, physicalName),
+		reference: physicalReference,
+		provenance: {
+			kind: "create-sql",
+			dialect: "sqlite",
+			reference: physicalReference
+		},
+		dialect: extension({ objectKind: "view" })
+	};
+}
+function viewDefinition(sqlText) {
+	if (!sqlText) return;
+	return sqlText.match(/\bAS\b([\s\S]*)$/i)?.[1]?.trim().replace(/;\s*$/, "") || void 0;
+}
+function attachedDatabaseObject(row, selectedNamespace) {
+	const physicalName = text(row.name) ?? "unnamed_database";
+	const physicalReference = reference("opaque-object", physicalName, selectedNamespace, "pragma_database_list", "name");
+	return {
+		kind: "opaque-object",
+		id: stableId(`attached:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: "attached-database",
+		physicalName,
+		data: {
+			...number(row.seq) === void 0 ? {} : { sequence: number(row.seq) },
+			...text(row.file) === void 0 ? {} : { file: text(row.file) },
+			selected: false
+		},
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "sqlite",
+			reference: physicalReference
+		},
+		dialect: extension({ selectedNamespace })
+	};
+}
+function opaqueSchemaObject(row, namespace, _diagnostics) {
+	const physicalName = text(row.name) ?? "unnamed_object";
+	const type = normalizeType(row.type) || "unknown";
+	const physicalReference = reference("opaque-object", physicalName, namespace, "sqlite_schema", "name");
+	const sqlText = text(row.sql);
+	return {
+		kind: "opaque-object",
+		id: stableId(`opaque:${type}:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: type,
+		physicalName,
+		data: {
+			type,
+			...text(row.tbl_name) === void 0 ? {} : { tableName: text(row.tbl_name) }
+		},
+		...sqlText === void 0 ? {} : { sql: {
+			kind: "sql",
+			dialect: "sqlite",
+			text: sqlText,
+			provenance: {
+				kind: "create-sql",
+				dialect: "sqlite",
+				reference: physicalReference
+			}
+		} },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "sqlite",
+			reference: physicalReference
+		},
+		dialect: extension({ objectKind: type })
+	};
+}
+function mapTrigger(row, namespace, relations, diagnostics) {
+	const physicalName = text(row.name) ?? "unnamed_trigger";
+	const sqlText = text(row.sql);
+	const physicalReference = reference("trigger", physicalName, namespace, "sqlite_schema", "name");
+	const onMatch = sqlText?.match(/\bON\s+("(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|[A-Za-z_][A-Za-z0-9_$]*)/i);
+	const targetName = unquoteIdentifier(onMatch?.[1]) ?? text(row.tbl_name);
+	const target = targetName === void 0 ? void 0 : relations.get(targetName);
+	const beginIndex = sqlText?.search(/\bBEGIN\b/i) ?? -1;
+	const header = sqlText === void 0 || beginIndex < 0 ? void 0 : sqlText.slice(0, beginIndex);
+	const timing = triggerTiming(header);
+	const events = triggerEvents(header);
+	if (!sqlText || !target || !header || beginIndex < 0) {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "unresolved-reference",
+			message: `SQLite trigger ${physicalName} does not have a recoverable body or target`,
+			path: ["triggers", physicalName],
+			physicalReference,
+			remediation: "Retain the CREATE TRIGGER SQL and inspect the trigger after its target is visible."
+		}));
+		return deferred("trigger", physicalName, sqlText, namespace);
+	}
+	if (events.length === 0) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "unsupported-feature",
+		message: `SQLite trigger ${physicalName} has no recognized event`,
+		path: [
+			"triggers",
+			physicalName,
+			"events"
+		],
+		physicalReference
+	}));
+	const bodyText = sqlText.slice(beginIndex + 5).replace(/END\s*;?\s*$/i, "").trim();
+	const condition = triggerCondition(sqlText, onMatch?.index, beginIndex);
+	return {
+		kind: "trigger",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		table: target,
+		timing,
+		events,
+		orientation: /\bFOR\s+EACH\s+ROW\b/i.test(header) ? "row" : void 0,
+		...condition === void 0 ? {} : { condition: sql(condition, namespace, {
+			kind: target.kind,
+			physicalName: target.id,
+			reference: physicalReference
+		}, physicalName) },
+		body: sql(bodyText || sqlText, namespace, {
+			kind: "trigger",
+			physicalName,
+			reference: physicalReference
+		}, physicalName),
+		reference: physicalReference,
+		provenance: {
+			kind: "create-sql",
+			dialect: "sqlite",
+			reference: physicalReference
+		},
+		dialect: extension({
+			objectKind: "trigger",
+			...sqlText === void 0 ? {} : { rawSql: sqlText }
+		})
+	};
+}
+function triggerTiming(header) {
+	const value = header?.match(/\b(INSTEAD\s+OF|BEFORE|AFTER)\b/i)?.[1];
+	return value?.toLowerCase() === "before" ? "before" : value?.toLowerCase() === "after" ? "after" : value?.toLowerCase() === "instead of" ? "instead-of" : "unknown";
+}
+function triggerEvents(header) {
+	const values = header?.match(/\b(INSERT|UPDATE|DELETE)\b/gi) ?? [];
+	return [...new Set(values.map((value) => value.toLowerCase()))];
+}
+function triggerCondition(sqlText, _onIndex, beginIndex) {
+	return sqlText.slice(0, beginIndex).match(/\bWHEN\s+([\s\S]+)$/i)?.[1]?.trim();
+}
+function unquoteIdentifier(value) {
+	if (!value) return;
+	const trimmed = value.trim();
+	if (trimmed.length < 2) return trimmed;
+	if (trimmed.startsWith("\"") && trimmed.endsWith("\"") || trimmed.startsWith("`") && trimmed.endsWith("`")) return trimmed.slice(1, -1).replace(/(""|``)/g, (match) => match[0]);
+	if (trimmed.startsWith("[") && trimmed.endsWith("]")) return trimmed.slice(1, -1);
+	return trimmed;
+}
+function affinity(type) {
+	const normalized = type.trim().toUpperCase();
+	if (/INT/.test(normalized)) return "INTEGER";
+	if (/CHAR|CLOB|TEXT/.test(normalized)) return "TEXT";
+	if (/REAL|FLOA|DOUB/.test(normalized)) return "REAL";
+	if (normalized === "" || normalized === "BLOB") return "BLOB";
+	return "NUMERIC";
+}
+function extension(data) {
+	return {
+		dialect: "sqlite",
+		version: 1,
+		data
+	};
+}
+function indexExpressionFor(sqlText, position) {
+	if (!sqlText) return;
+	const open = sqlText.indexOf("(", sqlText.search(/\bON\b/i));
+	if (open < 0) return;
+	const close = matchingParen(sqlText, open);
+	if (close < 0) return;
+	const term = splitSqlList(sqlText.slice(open + 1, close))[position]?.trim();
+	return term && !isSimpleIdentifier(term) ? term : void 0;
+}
+function opaqueIndexExpression(table, indexName, position, info, sqlText, namespace) {
+	const physicalReference = reference("opaque-object", `${indexName}:${position}`, namespace, "pragma_index_xinfo", "seqno", position);
+	return {
+		kind: "opaque-object",
+		id: stableId(`index-expression:${table.physicalName}:${indexName}:${position}`),
+		identitySource: "deterministic-fallback",
+		objectKind: "index-expression-term",
+		physicalName: `${indexName}:${position}`,
+		data: {
+			index: indexName,
+			position,
+			cid: number(info.cid) ?? -2
+		},
+		...sqlText === void 0 ? {} : { sql: sql(sqlText, namespace, table, indexName) },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "sqlite",
+			reference: physicalReference
+		},
+		dialect: extension({ objectKind: "index-expression-term" })
+	};
+}
+function matchingParen(source, open) {
+	let depth = 0;
+	let quote;
+	for (let index = open; index < source.length; index++) {
+		const character = source[index];
+		if (quote === "single") {
+			if (character === "'" && source[index + 1] === "'") index++;
+			else if (character === "'") quote = void 0;
+			continue;
+		}
+		if (quote === "double") {
+			if (character === "\"" && source[index + 1] === "\"") index++;
+			else if (character === "\"") quote = void 0;
+			continue;
+		}
+		if (quote === "backtick") {
+			if (character === "`") quote = void 0;
+			continue;
+		}
+		if (quote === "bracket") {
+			if (character === "]") quote = void 0;
+			continue;
+		}
+		if (character === "'") quote = "single";
+		else if (character === "\"") quote = "double";
+		else if (character === "`") quote = "backtick";
+		else if (character === "[") quote = "bracket";
+		else if (character === "(") depth++;
+		else if (character === ")" && --depth === 0) return index;
+	}
+	return -1;
+}
+function splitSqlList(source) {
+	const values = [];
+	let start = 0;
+	let depth = 0;
+	let quote;
+	for (let index = 0; index < source.length; index++) {
+		const character = source[index];
+		if (quote === "single") {
+			if (character === "'" && source[index + 1] === "'") index++;
+			else if (character === "'") quote = void 0;
+			continue;
+		}
+		if (quote === "double") {
+			if (character === "\"" && source[index + 1] === "\"") index++;
+			else if (character === "\"") quote = void 0;
+			continue;
+		}
+		if (quote === "backtick") {
+			if (character === "`") quote = void 0;
+			continue;
+		}
+		if (quote === "bracket") {
+			if (character === "]") quote = void 0;
+			continue;
+		}
+		if (character === "'") quote = "single";
+		else if (character === "\"") quote = "double";
+		else if (character === "`") quote = "backtick";
+		else if (character === "[") quote = "bracket";
+		else if (character === "(") depth++;
+		else if (character === ")") depth--;
+		else if (character === "," && depth === 0) {
+			values.push(source.slice(start, index));
+			start = index + 1;
+		}
+	}
+	values.push(source.slice(start));
+	return values;
+}
+function isSimpleIdentifier(value) {
+	return /^(?:[A-Za-z_][A-Za-z0-9_$]*|"(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\])(?:\s+(?:ASC|DESC))?$/i.test(value);
+}
+function table(row, sqlText, namespace) {
+	const physicalName = text(row.name) ?? "unnamed_table";
+	const withoutRowid = boolean(row.wr);
+	const strict = boolean(row.strict);
+	return {
+		kind: "table",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		reference: reference("table", physicalName, namespace, "sqlite_schema", "name"),
+		columns: [],
+		constraints: [],
+		indexes: [],
+		dialect: extension({
+			tableType: "table",
+			withoutRowid,
+			strict,
+			rowid: !withoutRowid
+		}),
+		unknownFields: [
+			...withoutRowid ? [{
+				name: "withoutRowid",
+				value: true
+			}] : [],
+			...strict ? [{
+				name: "strict",
+				value: true
+			}] : [],
+			...sqlText ? [{
+				name: "createSql",
+				value: sqlText
+			}] : []
+		]
+	};
+}
+function deferred(objectKind, physicalName, sqlText, namespace) {
+	return {
+		kind: "deferred-object",
+		id: stableId(`deferred:${objectKind}:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind,
+		physicalName,
+		reference: reference("deferred-object", physicalName, namespace, "sqlite_schema", "name"),
+		dialect: extension({ objectKind }),
+		unknownFields: sqlText ? [{
+			name: "createSql",
+			value: sqlText
+		}] : void 0
+	};
+}
+function column(row, table, namespace, sqlText, rowidPrimaryKey, diagnostics) {
+	const physicalName = text(row.name) ?? "unnamed_column";
+	const hidden = number(row.hidden) ?? 0;
+	const type = text(row.type) ?? "";
+	const defaultValue = text(row.dflt_value);
+	const generatedExpression = hidden === 2 || hidden === 3 ? generatedExpressionFor(sqlText, physicalName) : void 0;
+	if ((hidden === 2 || hidden === 3) && !generatedExpression) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "error",
+		code: "expression-parse-failed",
+		message: `SQLite generated expression for ${physicalName} could not be recovered`,
+		path: [
+			table.id,
+			"columns",
+			physicalName,
+			"generated"
+		],
+		remediation: "Preserve the CREATE TABLE SQL or use lossy mode."
+	}));
+	const rowid = table.kind === "table" && rowidPrimaryKey && (number(row.pk) ?? 0) > 0 && type.toUpperCase() === "INTEGER" && !/WITHOUT\s+ROWID/i.test(sqlText ?? "");
+	const identity = rowid ? {
+		kind: "identity",
+		generation: "by-default",
+		options: {},
+		dialect: {
+			dialect: "sqlite",
+			version: 1,
+			data: {
+				rowidAlias: true,
+				autoIncrement: /AUTOINCREMENT/i.test(sqlText ?? ""),
+				withoutRowid: false
+			}
+		}
+	} : void 0;
+	return {
+		kind: "column",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		ordinalPosition: (number(row.cid) ?? 0) + 1,
+		nullable: !boolean(row.not_null) && !(rowid || (number(row.pk) ?? 0) > 0 && (/WITHOUT\s+ROWID/i.test(sqlText ?? "") || /\bSTRICT\b/i.test(sqlText ?? ""))),
+		storage: { nativeType: type || "BLOB" },
+		default: defaultValue !== void 0 && !generatedExpression ? {
+			kind: "expression",
+			expression: sql(defaultValue, namespace, table, physicalName)
+		} : void 0,
+		generated: generatedExpression ? {
+			kind: "generated",
+			mode: hidden === 2 ? "virtual" : "stored",
+			expression: sql(generatedExpression, namespace, table, physicalName)
+		} : void 0,
+		identity,
+		reference: reference("column", physicalName, namespace, "pragma_table_xinfo", "name"),
+		dialect: extension({
+			declaredType: type,
+			affinity: affinity(type),
+			hidden
+		})
+	};
+}
+function tableConstraints(table, rows, columns, sqlText, namespace, diagnostics, opaqueObjects) {
+	const primaryNames = new Map(rows.filter((row) => (number(row.pk) ?? 0) > 0).map((row) => [text(row.name), number(row.pk) ?? 0]));
+	const primaryColumns = columns.filter((column) => primaryNames.has(column.physicalName)).sort((left, right) => primaryNames.get(left.physicalName) - primaryNames.get(right.physicalName));
+	const constraints = [];
+	if (primaryColumns.length > 0) {
+		const declaredName = declaredConstraintName(sqlText, "PRIMARY\\s+KEY", primaryColumns.map((column) => column.physicalName));
+		const primaryName = declaredName ?? `primary_${table.physicalName}`;
+		const primary = {
+			kind: "primary-key",
+			id: stableId(primaryName),
+			identitySource: declaredName ? "physical-name" : "deterministic-fallback",
+			physicalName: primaryName,
+			columns: primaryColumns.map((column) => column.physicalName),
+			dialect: extension({ source: "pragma_table_xinfo" }),
+			reference: reference("constraint", primaryName, namespace, "sqlite_schema", "tbl_name")
+		};
+		constraints.push(primary);
+	}
+	const checkResult = checkExpressions(sqlText);
+	checkResult.values.forEach((checkValue, index) => {
+		const name = checkValue.name ?? `check_${index}_${table.physicalName}`;
+		const check = {
+			kind: "check",
+			id: stableId(name),
+			identitySource: "deterministic-fallback",
+			physicalName: name,
+			expression: sql(checkValue.expression, namespace, table, name),
+			dialect: extension({ source: "create-sql" })
+		};
+		constraints.push(check);
+	});
+	if (checkResult.unrecoverable) {
+		const name = checkResult.unrecoverableName ?? `check_${checkResult.values.length}_${table.physicalName}`;
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "expression-parse-failed",
+			message: `SQLite CHECK constraint ${name} could not be recovered from CREATE TABLE SQL`,
+			path: [
+				table.id,
+				"constraints",
+				name
+			],
+			physicalReference: reference("opaque-object", name, namespace, "sqlite_schema", "name"),
+			remediation: "Preserve the complete CREATE TABLE SQL or use lossy mode."
+		}));
+		opaqueObjects.push(opaqueCheckConstraint(table, name, sqlText, namespace));
+	}
+	return constraints;
+}
+function checkExpressions(sqlText) {
+	if (!sqlText) return {
+		values: [],
+		unrecoverable: false
+	};
+	const values = [];
+	let offset = 0;
+	while (offset < sqlText.length) {
+		const checkIndex = findSqlKeyword(sqlText, "CHECK", offset);
+		if (checkIndex < 0) return {
+			values,
+			unrecoverable: false
+		};
+		let open = checkIndex + 5;
+		while (/\s/.test(sqlText[open] ?? "")) open++;
+		if (sqlText[open] !== "(") {
+			offset = checkIndex + 5;
+			continue;
+		}
+		const close = matchingParen(sqlText, open);
+		if (close < 0) return {
+			values,
+			unrecoverable: true,
+			unrecoverableName: checkConstraintName(sqlText, checkIndex)
+		};
+		values.push({
+			name: checkConstraintName(sqlText, checkIndex),
+			expression: sqlText.slice(open + 1, close).trim()
+		});
+		offset = close + 1;
+	}
+	return {
+		values,
+		unrecoverable: false
+	};
+}
+function findSqlKeyword(source, keyword, start) {
+	let quote;
+	for (let index = start; index < source.length; index++) {
+		const character = source[index];
+		if (quote === "single") {
+			if (character === "'" && source[index + 1] === "'") index++;
+			else if (character === "'") quote = void 0;
+			continue;
+		}
+		if (quote === "double") {
+			if (character === "\"" && source[index + 1] === "\"") index++;
+			else if (character === "\"") quote = void 0;
+			continue;
+		}
+		if (quote === "backtick") {
+			if (character === "`") quote = void 0;
+			continue;
+		}
+		if (quote === "bracket") {
+			if (character === "]") quote = void 0;
+			continue;
+		}
+		if (character === "'") {
+			quote = "single";
+			continue;
+		}
+		if (character === "\"") {
+			quote = "double";
+			continue;
+		}
+		if (character === "`") {
+			quote = "backtick";
+			continue;
+		}
+		if (character === "[") {
+			quote = "bracket";
+			continue;
+		}
+		if (source.slice(index, index + keyword.length).toUpperCase() === keyword.toUpperCase() && !isSqlIdentifierCharacter(source[index - 1]) && !isSqlIdentifierCharacter(source[index + keyword.length])) return index;
+	}
+	return -1;
+}
+function isSqlIdentifierCharacter(value) {
+	return value !== void 0 && /[A-Za-z0-9_$]/.test(value);
+}
+function checkConstraintName(source, checkIndex) {
+	return unquoteIdentifier(source.slice(0, checkIndex).match(/CONSTRAINT\s+("(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|[A-Za-z_][A-Za-z0-9_$]*)\s*$/i)?.[1]);
+}
+function opaqueCheckConstraint(table, constraintName, sqlText, namespace) {
+	const physicalReference = reference("opaque-object", constraintName, namespace, "sqlite_schema", "name", table.physicalName);
+	return {
+		kind: "opaque-object",
+		id: stableId(`check:${table.physicalName}:${constraintName}`),
+		identitySource: "deterministic-fallback",
+		objectKind: "check-constraint",
+		physicalName: constraintName,
+		data: {
+			table: table.physicalName,
+			reason: "definition-unavailable"
+		},
+		...sqlText === void 0 ? {} : { sql: sql(sqlText, namespace, table, constraintName) },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "sqlite",
+			reference: physicalReference
+		}
+	};
+}
+function mapIndex(table, row, infoRows, sqlText, namespace, diagnostics, opaqueObjects) {
+	const physicalName = text(row.name);
+	if (!physicalName) return;
+	const terms = [];
+	const collations = [];
+	for (const info of infoRows.filter((item) => boolean(item.key))) {
+		const position = number(info.seqno) ?? 0;
+		const cid = number(info.cid) ?? -1;
+		const collation = text(info.coll);
+		if (collation) collations.push(collation);
+		if (cid === -1) continue;
+		if (cid === -2) {
+			const expressionText = indexExpressionFor(sqlText, position);
+			if (expressionText) terms.push({
+				kind: "expression",
+				expression: sql(expressionText, namespace, table, physicalName),
+				position,
+				direction: boolean(info.descending) ? "DESC" : "ASC"
+			});
+			else {
+				opaqueObjects.push(opaqueIndexExpression(table, physicalName, position, info, sqlText, namespace));
+				diagnostics.push(createIntrospectionDiagnostic({
+					severity: "error",
+					code: "unsupported-feature",
+					message: `SQLite index ${physicalName} has an expression term that was not recovered`,
+					path: [
+						table.id,
+						"indexes",
+						physicalName,
+						"terms",
+						position
+					],
+					physicalReference: reference("index", physicalName, namespace, "sqlite_schema", "name"),
+					remediation: "Preserve the CREATE INDEX SQL for expression terms."
+				}));
+			}
+			continue;
+		}
+		const columnName = text(info.name);
+		if (cid >= 0 && columnName) terms.push({
+			kind: "column",
+			column: columnName,
+			position,
+			direction: boolean(info.descending) ? "DESC" : "ASC"
+		});
+		else diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "unsupported-feature",
+			message: `SQLite index ${physicalName} has an expression term that was not recovered`,
+			path: [
+				table.id,
+				"indexes",
+				physicalName,
+				"terms",
+				position
+			],
+			physicalReference: reference("index", physicalName, namespace, "sqlite_schema", "name")
+		}));
+	}
+	const unique = boolean(row.unique_index);
+	if (text(row.origin) === "u") {
+		const internalName = physicalName.startsWith("sqlite_autoindex_");
+		const termNames = terms.map((term) => term.kind === "column" ? term.column : `expression_${term.position}`);
+		const declaredName = declaredConstraintName(sqlText, "UNIQUE", termNames);
+		const constraintName = internalName ? declaredName ?? `unique_${table.physicalName}_${termNames.join("_") || "constraint"}` : physicalName;
+		return {
+			kind: "unique",
+			id: stableId(constraintName),
+			identitySource: internalName && !declaredName ? "deterministic-fallback" : "physical-name",
+			physicalName: constraintName,
+			columns: terms.flatMap((term) => term.kind === "column" ? [term.column] : []),
+			nulls: "distinct",
+			dialect: extension({
+				origin: text(row.origin) ?? "unknown",
+				collations,
+				...internalName ? { internalName } : {}
+			}),
+			reference: reference("constraint", constraintName, namespace, "pragma_index_list", "name", physicalName)
+		};
+	}
+	return {
+		kind: "index",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		unique,
+		terms,
+		dialect: extension({
+			origin: text(row.origin) ?? "unknown",
+			partial: boolean(row.partial),
+			collations
+		}),
+		predicate: boolean(row.partial) ? partialPredicate(sqlText, physicalName, namespace, table) : void 0,
+		reference: reference("index", physicalName, namespace, "sqlite_schema", "name")
+	};
+}
+function declaredConstraintName(sqlText, keyword, columns) {
+	if (!sqlText) return void 0;
+	const pattern = new RegExp(`CONSTRAINT\\s+("(?:[^"]|"")*"|\`[^\`]*\`|\\[[^\\]]*\\]|[A-Za-z_][A-Za-z0-9_\$]*)\\s+${keyword}\\s*\\(([^)]*)\\)`, "gi");
+	for (const match of sqlText.matchAll(pattern)) {
+		const found = (match[2] ?? "").split(",").map((value) => unquoteIdentifier(value.trim())).filter((value) => value !== void 0);
+		if (found.length === columns.length && found.every((value, index) => value === columns[index])) return unquoteIdentifier(match[1]);
+	}
+}
+function foreignKeys(table, rows, tables, namespace, diagnostics) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const id = text(row.id) ?? "0";
+		const group = grouped.get(id) ?? [];
+		group.push(row);
+		grouped.set(id, group);
+	}
+	return [...grouped.entries()].map(([key, group]) => {
+		const ordered = [...group].sort((left, right) => (number(left.seq) ?? 0) - (number(right.seq) ?? 0));
+		const first = ordered[0];
+		const physicalName = `foreign_key_${table.physicalName}_${key}`;
+		const targetTableName = text(first.target_table);
+		const targetTable = targetTableName === void 0 ? void 0 : tables.get(targetTableName);
+		const targetColumns = ordered.map((row) => text(row.target_column));
+		const sourceColumns = ordered.map((row) => text(row.source_column));
+		const explicitTargetColumns = targetColumns.every((column) => column !== void 0);
+		const implicitTargetColumns = targetColumns.every((column) => column === void 0);
+		let normalizedTargetColumns;
+		let problem;
+		if (targetTableName === void 0) problem = "has no referenced table";
+		else if (targetTable === void 0) problem = `references table ${targetTableName}, which is not visible`;
+		else if (implicitTargetColumns) {
+			const primaryKey = targetTable.constraints.find((constraint) => constraint.kind === "primary-key");
+			if (primaryKey === void 0) problem = `references ${targetTableName} without target columns, but that table has no declared primary key`;
+			else if (primaryKey.columns.length !== ordered.length) problem = `references ${targetTableName} without target columns with an incompatible primary-key width`;
+			else normalizedTargetColumns = primaryKey.columns;
+		} else if (explicitTargetColumns) normalizedTargetColumns = targetColumns;
+		else problem = "has a mixture of explicit and implicit target columns";
+		if (sourceColumns.some((column) => column === void 0)) problem = problem ?? "has an unresolved source column";
+		const physicalReference = reference("opaque-object", physicalName, namespace, "pragma_foreign_key_list", "id", key);
+		if (problem !== void 0 || targetTableName === void 0 || normalizedTargetColumns === void 0) {
+			diagnostics.push(createIntrospectionDiagnostic({
+				severity: "error",
+				code: "unresolved-reference",
+				message: `SQLite foreign key ${physicalName} ${problem ?? "has no recoverable target columns"}`,
+				path: [
+					table.id,
+					"constraints",
+					physicalName,
+					"target"
+				],
+				physicalReference,
+				remediation: "Declare explicit target columns or expose the referenced table primary key."
+			}));
+			return opaqueForeignKey(table, physicalName, key, targetTableName, sourceColumns, targetColumns, physicalReference);
+		}
+		return {
+			kind: "foreign-key",
+			id: stableId(physicalName),
+			identitySource: "deterministic-fallback",
+			physicalName,
+			columns: sourceColumns,
+			target: {
+				table: targetTableName,
+				columns: normalizedTargetColumns
+			},
+			onUpdate: action(first.on_update),
+			onDelete: action(first.on_delete),
+			match: match(first.match),
+			dialect: extension({ foreignKeyId: key }),
+			reference: reference("constraint", physicalName, namespace, "pragma_foreign_key_list", "id", key)
+		};
+	});
+}
+function opaqueForeignKey(table, physicalName, key, targetTable, sourceColumns, targetColumns, physicalReference) {
+	return {
+		kind: "opaque-object",
+		id: stableId(`foreign-key:${table.physicalName}:${key}`),
+		identitySource: "deterministic-fallback",
+		objectKind: "foreign-key",
+		physicalName,
+		data: {
+			table: table.physicalName,
+			foreignKeyId: key,
+			...targetTable === void 0 ? {} : { targetTable },
+			sourceColumns: sourceColumns.map((column) => column ?? null),
+			targetColumns: targetColumns.map((column) => column ?? null)
+		},
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "sqlite",
+			reference: physicalReference
+		}
+	};
+}
+function partialPredicate(sqlText, indexName, namespace, table) {
+	const predicate = (sqlText?.match(/\bWHERE\s+([\s\S]+)$/i))?.[1]?.trim().replace(/;\s*$/, "");
+	return predicate ? sql(predicate, namespace, table, indexName) : void 0;
+}
+function generatedExpressionFor(sqlText, columnName) {
+	if (!sqlText) return;
+	const open = sqlText.indexOf("(");
+	if (open < 0) return;
+	const close = matchingParen(sqlText, open);
+	if (close < 0) return;
+	const definitions = splitSqlList(sqlText.slice(open + 1, close));
+	for (const definition of definitions) {
+		const identifier = definition.trim().match(/^("(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|[A-Za-z_][A-Za-z0-9_$]*)/)?.[1];
+		if (unquoteIdentifier(identifier) !== columnName) continue;
+		const generated = definition.match(/\bAS\s*\(/i);
+		if (!generated || generated.index === void 0) return;
+		const generatedOpen = definition.indexOf("(", generated.index);
+		if (generatedOpen < 0) return;
+		const generatedClose = matchingParen(definition, generatedOpen);
+		return generatedClose < 0 ? void 0 : definition.slice(generatedOpen + 1, generatedClose).trim();
+	}
+}
+function sql(textValue, dialectNamespace, owner, name) {
+	const ownerReference = owner.reference ?? reference(owner.kind, owner.physicalName, dialectNamespace, "sqlite_schema", "name");
+	return {
+		kind: "sql",
+		dialect: "sqlite",
+		text: textValue,
+		provenance: {
+			kind: "create-sql",
+			dialect: "sqlite",
+			reference: reference(ownerReference.kind, name, dialectNamespace, ownerReference.catalog?.relation ?? "sqlite_schema", ownerReference.catalog?.key ?? "name", ownerReference.catalog?.value ?? ownerReference.name)
+		}
+	};
+}
+function reference(kind, name, namespace, relation, key, value = name) {
+	return {
+		kind,
+		name,
+		namespace,
+		catalog: {
+			relation,
+			key,
+			value
+		}
+	};
+}
+function emptyCatalog(namespace, diagnostics) {
+	return {
+		dialect: "sqlite",
+		server: {
+			product: "sqlite",
+			rawVersion: "unknown",
+			capabilities: {
+				generatedColumns: false,
+				identityMetadata: false,
+				checkConstraints: false,
+				checkConstraintEnforcement: "unknown",
+				expressionDecompilation: false,
+				indexExpressions: false,
+				indexPredicates: false,
+				indexIncludedColumns: false,
+				namespaces: false,
+				visibility: "unknown"
+			}
+		},
+		namespace: {
+			kind: "sqlite-database",
+			name: namespace
+		},
+		tables: [],
+		deferredObjects: [],
+		diagnostics
+	};
+}
+function stableId(value) {
+	if (value && !/[.\\\u0000-\u001f\u007f]/.test(value)) return value;
+	let hash = 2166136261;
+	for (const character of value) {
+		hash ^= character.charCodeAt(0);
+		hash = Math.imul(hash, 16777619);
+	}
+	return `introspected_${(hash >>> 0).toString(16)}`;
+}
+function text(value) {
+	return value === null || value === void 0 ? void 0 : String(value);
+}
+function number(value) {
+	if (typeof value === "number" && Number.isFinite(value)) return value;
+	if (typeof value === "string" && value.trim() !== "") {
+		const result = Number(value);
+		return Number.isFinite(result) ? result : void 0;
+	}
+}
+function boolean(value) {
+	return value === true || value === 1 || value === "1" || value === "t" || value === "true";
+}
+function action(value) {
+	const normalized = text(value)?.toLowerCase();
+	return normalized === "cascade" ? "cascade" : normalized === "restrict" ? "restrict" : normalized === "set null" ? "set-null" : normalized === "set default" ? "set-default" : "no-action";
+}
+function match(value) {
+	const normalized = text(value)?.toLowerCase();
+	return normalized === "full" ? "full" : normalized === "partial" ? "partial" : "simple";
+}
+//#endregion
+export { readCatalog, sqliteDatabaseListQuery, sqliteForeignKeyQuery, sqliteIndexInfoQuery, sqliteIndexListQuery, sqliteSchemaQuery, sqliteServerQuery, sqliteTableInfoQuery, sqliteTableListQuery, sqliteTempSchemaQuery };