qubu 0.6.0 → 0.6.1

package/dist/introspection.mjs

@@ -1,5 +1,6 @@
 import { a as toSnapshotJsonValue } from "./canonical-DMvR9yBe.mjs";
-import { a as hasIntrospectionErrors, i as createIntrospectionDiagnostic, n as introspectedPhysicalIdentityPolicy, r as IntrospectionError, t as mapCatalogToSnapshot } from "./snapshot-Xam8-q0j.mjs";
+import { n as createIntrospectionDiagnostic, r as hasIntrospectionErrors, t as IntrospectionError } from "./diagnostics-I9vVtXkc.mjs";
+import { n as introspectedPhysicalIdentityPolicy, t as mapCatalogToSnapshot } from "./snapshot-DgsOhf_8.mjs";
 import { n as assertCompleteSchemaSnapshot } from "./complete-DP7pliuY.mjs";
 import "./snapshot.mjs";
 //#region src/introspection/catalog.ts
@@ -186,7 +187,7 @@ function mapTable(table, dialect, tables, diagnostics) {
 	const columns = table.columns.map((column) => mapColumn(column, dialect)).sort(compareId);
 	const columnIds = new Map(table.columns.map((column) => [column.physicalName, column.id]));
 	const constraints = table.constraints.map((constraint) => mapConstraint(constraint, dialect, columnIds, tables, diagnostics)).filter((value) => value !== void 0).sort(compareId);
-	const indexes = table.indexes.map((index) => mapIndex$1(index, dialect, columnIds)).sort(compareId);
+	const indexes = table.indexes.map((index) => mapIndex(index, dialect, columnIds)).sort(compareId);
 	return {
 		kind: "table",
 		id: table.id,
@@ -298,7 +299,7 @@ function mapConstraint(constraint, dialect, columns, tables, diagnostics) {
 		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
 	};
 }
-function mapIndex$1(index, dialect, columns) {
+function mapIndex(index, dialect, columns) {
 	return {
 		kind: "index",
 		id: index.id,
@@ -669,3683 +670,4 @@ function isCatalogSqlExpression(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value) && value.kind === "sql" && typeof value.text === "string";
 }
 //#endregion
-//#region src/introspection/mysql.ts
-const mysqlServerQuery = `SELECT VERSION() AS version, @@version_comment AS version_comment`;
-const mysqlTablesQuery = `
-  SELECT TABLE_NAME AS table_name, TABLE_TYPE AS table_type,
-         ENGINE AS engine, TABLE_COLLATION AS table_collation,
-         CREATE_OPTIONS AS create_options, TABLE_COMMENT AS table_comment
-  FROM INFORMATION_SCHEMA.TABLES
-  WHERE TABLE_SCHEMA = ?
-  ORDER BY TABLE_NAME
-`;
-const mysqlColumnsQuery = `
-  SELECT TABLE_NAME AS table_name, COLUMN_NAME AS column_name,
-         ORDINAL_POSITION AS ordinal_position, COLUMN_TYPE AS column_type,
-         DATA_TYPE AS data_type,
-         IS_NULLABLE AS is_nullable, COLUMN_DEFAULT AS column_default,
-         EXTRA AS extra, GENERATION_EXPRESSION AS generation_expression,
-         CHARACTER_SET_NAME AS character_set_name,
-         COLLATION_NAME AS collation_name, COLUMN_COMMENT AS column_comment
-  FROM INFORMATION_SCHEMA.COLUMNS
-  WHERE TABLE_SCHEMA = ?
-  ORDER BY TABLE_NAME, ORDINAL_POSITION
-`;
-const mysqlKeyUsageQuery = `
-  SELECT kcu.TABLE_NAME AS table_name, kcu.CONSTRAINT_NAME AS constraint_name,
-         tc.CONSTRAINT_TYPE AS constraint_type, tc.ENFORCED AS enforced,
-         kcu.COLUMN_NAME AS column_name, kcu.ORDINAL_POSITION AS ordinal_position,
-         kcu.REFERENCED_TABLE_NAME AS referenced_table_name,
-         kcu.REFERENCED_COLUMN_NAME AS referenced_column_name,
-         rc.UPDATE_RULE AS update_rule, rc.DELETE_RULE AS delete_rule,
-         rc.MATCH_OPTION AS match_option
-  FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE kcu
-  JOIN INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
-    ON tc.CONSTRAINT_SCHEMA = kcu.CONSTRAINT_SCHEMA
-   AND tc.TABLE_NAME = kcu.TABLE_NAME
-   AND tc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
-  LEFT JOIN INFORMATION_SCHEMA.REFERENTIAL_CONSTRAINTS rc
-    ON rc.CONSTRAINT_SCHEMA = kcu.CONSTRAINT_SCHEMA
-   AND rc.TABLE_NAME = kcu.TABLE_NAME
-   AND rc.CONSTRAINT_NAME = kcu.CONSTRAINT_NAME
-  WHERE kcu.CONSTRAINT_SCHEMA = ?
-  ORDER BY kcu.TABLE_NAME, kcu.CONSTRAINT_NAME, kcu.ORDINAL_POSITION
-`;
-const mysqlChecksQuery = `
-  SELECT tc.TABLE_NAME AS table_name, tc.CONSTRAINT_NAME AS constraint_name,
-         tc.ENFORCED AS enforced, cc.CHECK_CLAUSE AS check_clause
-  FROM INFORMATION_SCHEMA.TABLE_CONSTRAINTS tc
-  JOIN INFORMATION_SCHEMA.CHECK_CONSTRAINTS cc
-    ON cc.CONSTRAINT_SCHEMA = tc.CONSTRAINT_SCHEMA
-   AND cc.CONSTRAINT_NAME = tc.CONSTRAINT_NAME
-  WHERE tc.CONSTRAINT_SCHEMA = ? AND tc.CONSTRAINT_TYPE = 'CHECK'
-  ORDER BY tc.TABLE_NAME, tc.CONSTRAINT_NAME
-`;
-const mysqlStatisticsQuery = `
-  SELECT TABLE_NAME AS table_name, INDEX_NAME AS index_name,
-         NON_UNIQUE AS non_unique, SEQ_IN_INDEX AS seq_in_index,
-         COLUMN_NAME AS column_name, COLLATION AS collation,
-         INDEX_TYPE AS index_type, EXPRESSION AS expression,
-         SUB_PART AS sub_part, IS_VISIBLE AS is_visible,
-         COMMENT AS comment, INDEX_COMMENT AS index_comment
-  FROM INFORMATION_SCHEMA.STATISTICS
-  WHERE TABLE_SCHEMA = ?
-  ORDER BY TABLE_NAME, INDEX_NAME, SEQ_IN_INDEX
-`;
-/** View definitions and execution properties for the selected database. */
-const mysqlViewsQuery = `
-  SELECT TABLE_NAME AS table_name, VIEW_DEFINITION AS view_definition,
-         CHECK_OPTION AS check_option, IS_UPDATABLE AS is_updatable,
-         SECURITY_TYPE AS security_type, DEFINER AS definer
-  FROM INFORMATION_SCHEMA.VIEWS
-  WHERE TABLE_SCHEMA = ?
-  ORDER BY TABLE_NAME
-`;
-/** Stored function and procedure declarations for the selected database. */
-const mysqlRoutinesQuery = `
-  SELECT ROUTINE_NAME AS routine_name, ROUTINE_TYPE AS routine_type,
-         DATA_TYPE AS data_type, DTD_IDENTIFIER AS dtd_identifier,
-         ROUTINE_BODY AS routine_body,
-         ROUTINE_DEFINITION AS routine_definition,
-         EXTERNAL_LANGUAGE AS external_language,
-         SQL_DATA_ACCESS AS sql_data_access,
-         IS_DETERMINISTIC AS is_deterministic,
-         SECURITY_TYPE AS security_type, SQL_MODE AS sql_mode,
-         ROUTINE_COMMENT AS routine_comment
-  FROM INFORMATION_SCHEMA.ROUTINES
-  WHERE ROUTINE_SCHEMA = ?
-  ORDER BY ROUTINE_NAME, ROUTINE_TYPE
-`;
-/** Parameter rows, including the ordinal zero return row for functions. */
-const mysqlRoutineParametersQuery = `
-  SELECT SPECIFIC_NAME AS routine_name, ORDINAL_POSITION AS ordinal_position,
-         PARAMETER_MODE AS parameter_mode, PARAMETER_NAME AS parameter_name,
-         DATA_TYPE AS data_type, DTD_IDENTIFIER AS dtd_identifier
-  FROM INFORMATION_SCHEMA.PARAMETERS
-  WHERE SPECIFIC_SCHEMA = ?
-  ORDER BY SPECIFIC_NAME, ORDINAL_POSITION
-`;
-/** Trigger bodies and their table/event metadata. */
-const mysqlTriggersQuery = `
-  SELECT TRIGGER_NAME AS trigger_name, EVENT_MANIPULATION AS event_manipulation,
-         EVENT_OBJECT_TABLE AS table_name, ACTION_CONDITION AS action_condition,
-         ACTION_STATEMENT AS action_statement,
-         ACTION_ORIENTATION AS action_orientation,
-         ACTION_TIMING AS action_timing, ACTION_ORDER AS action_order,
-         DEFINER AS definer, SQL_MODE AS sql_mode
-  FROM INFORMATION_SCHEMA.TRIGGERS
-  WHERE TRIGGER_SCHEMA = ?
-  ORDER BY TRIGGER_NAME, ACTION_ORDER
-`;
-/** Partition and subpartition declarations for tables in the selected database. */
-const mysqlPartitionsQuery = `
-  SELECT TABLE_NAME AS table_name, PARTITION_NAME AS partition_name,
-         SUBPARTITION_NAME AS subpartition_name,
-         PARTITION_ORDINAL_POSITION AS partition_ordinal_position,
-         SUBPARTITION_ORDINAL_POSITION AS subpartition_ordinal_position,
-         PARTITION_METHOD AS partition_method,
-         SUBPARTITION_METHOD AS subpartition_method,
-         PARTITION_EXPRESSION AS partition_expression,
-         SUBPARTITION_EXPRESSION AS subpartition_expression,
-         PARTITION_DESCRIPTION AS partition_description,
-         PARTITION_COMMENT AS partition_comment,
-         TABLESPACE_NAME AS tablespace_name
-  FROM INFORMATION_SCHEMA.PARTITIONS
-  WHERE TABLE_SCHEMA = ? AND PARTITION_NAME IS NOT NULL
-  ORDER BY TABLE_NAME, PARTITION_ORDINAL_POSITION, SUBPARTITION_ORDINAL_POSITION
-`;
-/** Collations used by tables or columns in the selected database. */
-const mysqlCollationsQuery = `
-  SELECT c.COLLATION_NAME AS collation_name,
-         c.CHARACTER_SET_NAME AS character_set_name,
-         c.ID AS collation_id, c.IS_DEFAULT AS is_default,
-         c.IS_COMPILED AS is_compiled, c.SORTLEN AS sort_length,
-         c.PAD_ATTRIBUTE AS pad_attribute
-  FROM INFORMATION_SCHEMA.COLLATIONS c
-  JOIN (
-    SELECT DISTINCT TABLE_COLLATION AS collation_name
-    FROM INFORMATION_SCHEMA.TABLES
-    WHERE TABLE_SCHEMA = ? AND TABLE_COLLATION IS NOT NULL
-    UNION
-    SELECT DISTINCT COLLATION_NAME AS collation_name
-    FROM INFORMATION_SCHEMA.COLUMNS
-    WHERE TABLE_SCHEMA = ? AND COLLATION_NAME IS NOT NULL
-  ) used ON used.collation_name = c.COLLATION_NAME
-  ORDER BY c.COLLATION_NAME
-`;
-/** Scheduled events are retained as opaque MySQL objects, not migration input. */
-const mysqlEventsQuery = `
-  SELECT EVENT_NAME AS event_name, EVENT_TYPE AS event_type,
-         STATUS AS status, EVENT_DEFINITION AS event_definition,
-         EVENT_BODY AS event_body, EXECUTE_AT AS execute_at,
-         INTERVAL_VALUE AS interval_value, INTERVAL_FIELD AS interval_field,
-         EVENT_COMMENT AS event_comment, DEFINER AS definer
-  FROM INFORMATION_SCHEMA.EVENTS
-  WHERE EVENT_SCHEMA = ?
-  ORDER BY EVENT_NAME
-`;
-/** Read one MySQL database into the normalized catalog contract. */
-async function readMysqlCatalog(connection, options) {
-	const diagnostics = [];
-	if (connection.dialect !== "mysql") {
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "dialect-mismatch",
-			message: "MySQL catalog reading requires a MySQL CatalogConnection",
-			path: ["connection", "dialect"]
-		}));
-		return emptyCatalog$2(options.namespace, diagnostics);
-	}
-	const server = serverInfo$2((await query$2(connection, mysqlServerQuery, [], options, diagnostics, "server"))[0], diagnostics);
-	const tableRows = await query$2(connection, mysqlTablesQuery, [options.namespace], options, diagnostics, "tables");
-	const tables = tableRows.filter((row) => text$2(row.table_type) === "BASE TABLE").map((row) => table$1(row, options.namespace));
-	const deferredObjects = [];
-	const opaqueObjects = [];
-	const views = [];
-	const comments = [];
-	const tableByName = new Map(tables.map((item) => [item.physicalName, item]));
-	const viewRows = await query$2(connection, mysqlViewsQuery, [options.namespace], options, diagnostics, "views");
-	const viewRowsByName = new Map(viewRows.map((row) => [text$2(row.table_name) ?? "", row]));
-	for (const row of tableRows.filter((currentRow) => text$2(currentRow.table_type) !== "BASE TABLE")) {
-		const kind = text$2(row.table_type)?.toUpperCase();
-		if (kind === "VIEW" || kind === "SYSTEM VIEW") {
-			const mapped = viewObject$1(row, viewRowsByName.get(text$2(row.table_name) ?? ""), options.namespace, diagnostics);
-			if (mapped.kind === "deferred-object") deferredObjects.push(mapped);
-			else views.push(mapped);
-		} else {
-			const mapped = deferred$1(row, options.namespace);
-			deferredObjects.push(mapped);
-			diagnostics.push(createIntrospectionDiagnostic({
-				severity: "warning",
-				code: "unmodeled-object",
-				message: `MySQL object ${mapped.physicalName} (${kind ?? "unknown"}) is retained as a deferred record`,
-				path: ["deferredObjects", mapped.physicalName],
-				physicalReference: mapped.reference,
-				remediation: "Inspect the deferred record before using it as migration input."
-			}));
-		}
-	}
-	const relationByName = /* @__PURE__ */ new Map();
-	for (const currentTable of tables) relationByName.set(currentTable.physicalName, {
-		kind: "table",
-		id: currentTable.id
-	});
-	for (const view of views) relationByName.set(view.physicalName, {
-		kind: "view",
-		id: view.id
-	});
-	const columnRows = await query$2(connection, mysqlColumnsQuery, [options.namespace], options, diagnostics, "columns");
-	for (const currentTable of tables) currentTable.columns = columnRows.filter((row) => text$2(row.table_name) === currentTable.physicalName).map((row) => column$2(row, currentTable, options.namespace));
-	for (const view of views) view.columns = columnRows.filter((row) => text$2(row.table_name) === view.physicalName).map((row) => column$2(row, view, options.namespace));
-	const keyRows = await query$2(connection, mysqlKeyUsageQuery, [options.namespace], options, diagnostics, "constraints");
-	for (const currentTable of tables) currentTable.constraints = constraints(currentTable, keyRows.filter((row) => text$2(row.table_name) === currentTable.physicalName), tableByName, options.namespace, diagnostics);
-	const checkRows = await query$2(connection, mysqlChecksQuery, [options.namespace], options, diagnostics, "checks");
-	const constraintsByTable = /* @__PURE__ */ new Map();
-	for (const currentTable of tables) constraintsByTable.set(currentTable.physicalName, [...currentTable.constraints]);
-	for (const row of checkRows) {
-		const currentTable = tableByName.get(text$2(row.table_name) ?? "");
-		if (!currentTable) continue;
-		const physicalName = text$2(row.constraint_name) ?? `check_${currentTable.physicalName}`;
-		const check = {
-			kind: "check",
-			id: stableId$2(physicalName),
-			identitySource: "physical-name",
-			physicalName,
-			expression: sql$2(text$2(row.check_clause) ?? "true", options.namespace, currentTable, physicalName),
-			dialect: text$2(row.enforced)?.toUpperCase() === "NO" ? {
-				dialect: "mysql",
-				version: 1,
-				data: { enforced: false }
-			} : void 0
-		};
-		constraintsByTable.get(currentTable.physicalName)?.push(check);
-	}
-	for (const currentTable of tables) currentTable.constraints = constraintsByTable.get(currentTable.physicalName) ?? [];
-	const statRows = await query$2(connection, mysqlStatisticsQuery, [options.namespace], options, diagnostics, "statistics");
-	const grouped = /* @__PURE__ */ new Map();
-	for (const row of statRows) {
-		const key = `${text$2(row.table_name) ?? ""}\u0000${text$2(row.index_name) ?? ""}`;
-		const group = grouped.get(key) ?? [];
-		group.push(row);
-		grouped.set(key, group);
-	}
-	for (const rows of grouped.values()) {
-		const currentTable = tableByName.get(text$2(rows[0].table_name) ?? "");
-		if (!currentTable) continue;
-		const mappedIndex = mapIndex(rows, currentTable, options.namespace, diagnostics);
-		if (mappedIndex) currentTable.indexes = [...currentTable.indexes, mappedIndex];
-	}
-	const routineRows = await query$2(connection, mysqlRoutinesQuery, [options.namespace], options, diagnostics, "routines");
-	const routineParameterRows = await query$2(connection, mysqlRoutineParametersQuery, [options.namespace], options, diagnostics, "routine-parameters");
-	const routineParameters = /* @__PURE__ */ new Map();
-	for (const row of routineParameterRows) {
-		const name = text$2(row.routine_name) ?? "unknown";
-		const group = routineParameters.get(name) ?? [];
-		group.push(row);
-		routineParameters.set(name, group);
-	}
-	const routines = routineRows.map((row) => {
-		const routine = routineObject(row, routineParameters.get(text$2(row.routine_name) ?? "") ?? [], options.namespace);
-		if (routine.comment) comments.push(routine.comment);
-		relationByName.set(routine.physicalName, {
-			kind: "routine",
-			id: routine.id
-		});
-		return routine;
-	});
-	const triggerRows = await query$2(connection, mysqlTriggersQuery, [options.namespace], options, diagnostics, "triggers");
-	const triggers = [];
-	for (const rows of groupRows(triggerRows, (row) => text$2(row.trigger_name) ?? "unknown")) {
-		const mapped = triggerObject$1(rows, relationByName, options.namespace, diagnostics);
-		if (mapped.kind === "trigger") triggers.push(mapped);
-		else deferredObjects.push(mapped);
-	}
-	const partitionRows = await query$2(connection, mysqlPartitionsQuery, [options.namespace], options, diagnostics, "partitions");
-	const partitions = [];
-	for (const row of partitionRows) {
-		const mapped = partitionObject$1(row, tableByName, options.namespace, diagnostics);
-		if (mapped.kind === "partition") {
-			partitions.push(mapped);
-			if (mapped.comment) comments.push(mapped.comment);
-		} else deferredObjects.push(mapped);
-	}
-	const collationRows = await query$2(connection, mysqlCollationsQuery, [options.namespace, options.namespace], options, diagnostics, "collations");
-	const usedCollations = new Set([...tableRows.map((row) => text$2(row.table_collation)), ...columnRows.map((row) => text$2(row.collation_name))].filter((value) => value !== void 0));
-	const collations = collationRows.filter((row) => {
-		const name = text$2(row.collation_name);
-		return name !== void 0 && usedCollations.has(name);
-	}).map((row) => collationObject$1(row, options.namespace));
-	const eventRows = await query$2(connection, mysqlEventsQuery, [options.namespace], options, diagnostics, "events");
-	for (const row of eventRows) {
-		const event = opaqueEvent(row, options.namespace);
-		opaqueObjects.push(event);
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "warning",
-			code: "unmodeled-object",
-			message: `MySQL event ${event.physicalName} is retained as opaque data`,
-			path: ["opaqueObjects", event.physicalName],
-			physicalReference: event.reference,
-			remediation: "Inspect the event definition before treating it as migration input."
-		}));
-		const eventComment = text$2(row.event_comment);
-		if (eventComment !== void 0 && eventComment !== "") comments.push(objectComment({
-			kind: "opaque-object",
-			id: event.id
-		}, eventComment, event.reference, options.namespace));
-	}
-	for (const currentTable of tables) {
-		const tableComment = text$2(tableRows.find((row) => text$2(row.table_name) === currentTable.physicalName)?.table_comment);
-		if (tableComment !== void 0 && tableComment !== "") comments.push(objectComment({
-			kind: "table",
-			id: currentTable.id
-		}, tableComment, currentTable.reference, options.namespace));
-		for (const currentColumn of currentTable.columns) {
-			const columnComment = text$2(columnRows.find((row) => text$2(row.table_name) === currentTable.physicalName && text$2(row.column_name) === currentColumn.physicalName)?.column_comment);
-			if (columnComment !== void 0 && columnComment !== "") comments.push(objectComment({
-				kind: "column",
-				id: currentColumn.id
-			}, columnComment, currentColumn.reference, options.namespace));
-		}
-	}
-	for (const view of views) {
-		const viewComment = text$2(tableRows.find((row) => text$2(row.table_name) === view.physicalName)?.table_comment);
-		if (viewComment !== void 0 && viewComment !== "") comments.push(objectComment({
-			kind: view.kind,
-			id: view.id
-		}, viewComment, view.reference, options.namespace));
-		for (const currentColumn of view.columns) {
-			const columnComment = text$2(columnRows.find((row) => text$2(row.table_name) === view.physicalName && text$2(row.column_name) === currentColumn.physicalName)?.column_comment);
-			if (columnComment !== void 0 && columnComment !== "") comments.push(objectComment({
-				kind: "column",
-				id: currentColumn.id
-			}, columnComment, currentColumn.reference, options.namespace));
-		}
-	}
-	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: server.capabilities.visibility
-	};
-	const serverCapabilities = {
-		...server.capabilities,
-		views: true,
-		materializedViews: false,
-		sequences: false,
-		enums: false,
-		domains: false,
-		collations: true,
-		routines: true,
-		triggers: true,
-		partitions: true,
-		policies: false,
-		extensions: false,
-		comments: true,
-		ownership: false,
-		scheduledEvents: true,
-		tableEngines: true,
-		generatedColumnModes: true,
-		selectedNamespace: options.namespace,
-		productFamily: server.product === "mariadb" ? "mariadb" : "mysql8"
-	};
-	const namespace = {
-		kind: "mysql-database",
-		name: options.namespace,
-		reference: reference$2("namespace", options.namespace, options.namespace, "INFORMATION_SCHEMA.SCHEMATA", "SCHEMA_NAME"),
-		dialect: mysqlExtension({
-			selectedNamespace: options.namespace,
-			views: true,
-			materializedViews: false,
-			sequences: false,
-			routines: true,
-			triggers: true,
-			partitions: true,
-			collations: true,
-			comments: true,
-			ownership: false,
-			policies: false,
-			extensions: false
-		})
-	};
-	return Object.freeze({
-		dialect: "mysql",
-		server: {
-			...server,
-			capabilities: serverCapabilities
-		},
-		namespace,
-		tables: Object.freeze(tables),
-		views: Object.freeze(views),
-		collations: Object.freeze(collations),
-		routines: Object.freeze(routines),
-		triggers: Object.freeze(triggers),
-		partitions: Object.freeze(partitions),
-		deferredObjects: Object.freeze(deferredObjects),
-		opaqueObjects: Object.freeze(opaqueObjects),
-		comments: Object.freeze(comments),
-		ownership: Object.freeze([]),
-		capabilities,
-		diagnostics: Object.freeze(diagnostics)
-	});
-}
-async function query$2(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: `MySQL catalog query failed while reading ${operation}`,
-			path: [operation],
-			remediation: "Check Information Schema permissions and the selected database."
-		}));
-		return [];
-	}
-}
-function serverInfo$2(row, diagnostics) {
-	const rawVersion = text$2(row?.version) ?? "unknown";
-	const comment = text$2(row?.version_comment) ?? "";
-	const mariadb = /mariadb/i.test(rawVersion) || /mariadb/i.test(comment);
-	const parts = rawVersion.match(/(\d+)\.(\d+)(?:\.(\d+))?/);
-	const major = parts ? Number(parts[1]) : void 0;
-	const minor = parts ? Number(parts[2]) : void 0;
-	if (mariadb) diagnostics.push(createIntrospectionDiagnostic({
-		severity: "error",
-		code: "unsupported-product",
-		message: "MariaDB requires a dedicated catalog adapter and is not treated as MySQL",
-		path: ["server", "product"]
-	}));
-	const supported = !mariadb && major === 8 && ((minor ?? 0) > 0 || (minor ?? 0) === 0 && Number(parts?.[3] ?? 0) >= 16);
-	if (!supported && !mariadb) diagnostics.push(createIntrospectionDiagnostic({
-		severity: "error",
-		code: "unsupported-server",
-		message: "MySQL introspection requires MySQL 8.0 or newer",
-		path: ["server", "version"]
-	}));
-	return {
-		product: mariadb ? "mariadb" : "mysql",
-		rawVersion,
-		parsedVersion: major === void 0 ? void 0 : {
-			major,
-			minor,
-			patch: parts?.[3] ? Number(parts[3]) : void 0
-		},
-		capabilities: {
-			generatedColumns: supported,
-			identityMetadata: supported,
-			checkConstraints: supported,
-			checkConstraintEnforcement: supported ? "enforced" : "unknown",
-			expressionDecompilation: false,
-			indexExpressions: supported,
-			indexPredicates: false,
-			indexIncludedColumns: false,
-			namespaces: true,
-			visibility: "complete",
-			mysql8: supported
-		}
-	};
-}
-function table$1(row, namespace) {
-	const physicalName = text$2(row.table_name) ?? "unnamed_table";
-	return {
-		kind: "table",
-		id: stableId$2(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		reference: reference$2("table", physicalName, namespace, "INFORMATION_SCHEMA.TABLES", "TABLE_NAME"),
-		columns: [],
-		constraints: [],
-		indexes: [],
-		dialect: mysqlExtension({
-			...text$2(row.engine) === void 0 ? {} : { engine: text$2(row.engine) },
-			...text$2(row.table_collation) === void 0 ? {} : { collation: text$2(row.table_collation) },
-			...text$2(row.create_options) === void 0 ? {} : { createOptions: text$2(row.create_options) }
-		})
-	};
-}
-function deferred$1(row, namespace) {
-	const physicalName = text$2(row.table_name) ?? "unnamed_object";
-	return {
-		kind: "deferred-object",
-		id: stableId$2(`deferred:${text$2(row.table_type) ?? "other"}:${physicalName}`),
-		identitySource: "physical-name",
-		objectKind: text$2(row.table_type)?.toUpperCase() === "VIEW" || text$2(row.table_type)?.toUpperCase() === "SYSTEM VIEW" ? "view" : "other",
-		physicalName,
-		reference: reference$2("deferred-object", physicalName, namespace, "INFORMATION_SCHEMA.TABLES", "TABLE_NAME"),
-		dialect: mysqlExtension({
-			...text$2(row.table_type) === void 0 ? {} : { tableType: text$2(row.table_type) },
-			...text$2(row.engine) === void 0 ? {} : { engine: text$2(row.engine) }
-		})
-	};
-}
-function column$2(row, table, namespace) {
-	const physicalName = text$2(row.column_name) ?? "unnamed_column";
-	const extra = text$2(row.extra) ?? "";
-	const generationExpression = text$2(row.generation_expression);
-	const generated = generationExpression !== void 0 && (/GENERATED/i.test(extra) || generationExpression !== "") ? {
-		kind: "generated",
-		mode: /VIRTUAL/i.test(extra) ? "virtual" : /STORED/i.test(extra) ? "stored" : "unknown",
-		expression: sql$2(generationExpression, namespace, table, physicalName)
-	} : void 0;
-	const identity = /auto_increment/i.test(extra) ? {
-		kind: "identity",
-		generation: "by-default",
-		options: {},
-		dialect: {
-			dialect: "mysql",
-			version: 1,
-			data: { autoIncrement: true }
-		}
-	} : void 0;
-	const onUpdateMatch = extra.match(/on update\s+(.+)$/i);
-	const defaultText = text$2(row.column_default);
-	const defaultValue = literal(defaultText, text$2(row.data_type));
-	return {
-		kind: "column",
-		id: stableId$2(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		ordinalPosition: number$2(row.ordinal_position) ?? 0,
-		nullable: text$2(row.is_nullable)?.toUpperCase() !== "NO",
-		storage: { nativeType: text$2(row.column_type) ?? "unknown" },
-		default: defaultValue !== void 0 ? {
-			kind: "literal",
-			value: defaultValue
-		} : defaultText !== void 0 ? {
-			kind: "expression",
-			expression: sql$2(defaultText, namespace, table, physicalName)
-		} : void 0,
-		generated,
-		identity,
-		onUpdate: onUpdateMatch?.[1] ? sql$2(onUpdateMatch[1], namespace, table, physicalName) : void 0,
-		dialect: mysqlExtension({
-			...text$2(row.data_type) === void 0 ? {} : { dataType: text$2(row.data_type) },
-			...text$2(row.character_set_name) === void 0 ? {} : { characterSet: text$2(row.character_set_name) },
-			...text$2(row.collation_name) === void 0 ? {} : { collation: text$2(row.collation_name) },
-			...extra === "" ? {} : { extra }
-		}),
-		reference: reference$2("column", physicalName, namespace, "INFORMATION_SCHEMA.COLUMNS", "COLUMN_NAME")
-	};
-}
-function constraints(table, rows, tableByName, namespace, diagnostics) {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const key = text$2(row.constraint_name) ?? "unknown";
-		const group = grouped.get(key) ?? [];
-		group.push(row);
-		grouped.set(key, group);
-	}
-	const result = [];
-	for (const [physicalName, group] of grouped) {
-		const first = group[0];
-		const columns = group.sort((left, right) => (number$2(left.ordinal_position) ?? 0) - (number$2(right.ordinal_position) ?? 0)).map((row) => text$2(row.column_name) ?? "unknown");
-		const common = {
-			id: stableId$2(physicalName),
-			identitySource: "physical-name",
-			physicalName,
-			reference: reference$2("constraint", physicalName, namespace, "INFORMATION_SCHEMA.TABLE_CONSTRAINTS", "CONSTRAINT_NAME")
-		};
-		const type = text$2(first.constraint_type);
-		if (type === "PRIMARY KEY") {
-			result.push({
-				kind: "primary-key",
-				...common,
-				columns
-			});
-			continue;
-		}
-		if (type === "UNIQUE") {
-			result.push({
-				kind: "unique",
-				...common,
-				columns,
-				nulls: "distinct"
-			});
-			continue;
-		}
-		if (type !== "FOREIGN KEY") continue;
-		const targetTableName = text$2(first.referenced_table_name) ?? "unknown";
-		if (!tableByName.has(targetTableName)) diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "unresolved-reference",
-			message: `MySQL foreign key target ${targetTableName} was not found`,
-			path: [
-				table.id,
-				"constraints",
-				physicalName
-			]
-		}));
-		result.push({
-			kind: "foreign-key",
-			...common,
-			columns,
-			target: {
-				table: targetTableName,
-				columns: group.map((row) => text$2(row.referenced_column_name) ?? "unknown")
-			},
-			onUpdate: action$1(first.update_rule),
-			onDelete: action$1(first.delete_rule),
-			match: match$1(first.match_option),
-			dialect: text$2(first.enforced)?.toUpperCase() === "NO" ? {
-				dialect: "mysql",
-				version: 1,
-				data: { enforced: false }
-			} : void 0
-		});
-	}
-	return result;
-}
-function mapIndex(rows, table, namespace, diagnostics) {
-	const first = rows[0];
-	const physicalName = text$2(first.index_name);
-	if (!physicalName) return;
-	const terms = [];
-	for (const row of rows) {
-		const expression = text$2(row.expression);
-		const columnName = text$2(row.column_name);
-		if (!expression && !columnName) {
-			diagnostics.push(createIntrospectionDiagnostic({
-				severity: "error",
-				code: "unsupported-feature",
-				message: `MySQL index ${physicalName} has an unrepresented term`,
-				path: [
-					table.id,
-					"indexes",
-					physicalName
-				]
-			}));
-			continue;
-		}
-		terms.push(expression ? {
-			kind: "expression",
-			expression: sql$2(expression, namespace, table, physicalName),
-			position: number$2(row.seq_in_index) ?? 0
-		} : {
-			kind: "column",
-			column: columnName,
-			position: number$2(row.seq_in_index) ?? 0,
-			direction: text$2(row.collation) === "D" ? "DESC" : "ASC",
-			prefixLength: row.sub_part === null || row.sub_part === void 0 ? void 0 : {
-				kind: "literal",
-				value: number$2(row.sub_part) ?? text$2(row.sub_part) ?? ""
-			}
-		});
-		if (row.sub_part !== null && row.sub_part !== void 0) diagnostics.push(createIntrospectionDiagnostic({
-			severity: "warning",
-			code: "lossy-mapping",
-			message: `MySQL index prefix length for ${physicalName} is retained only in catalog rows`,
-			path: [
-				table.id,
-				"indexes",
-				physicalName
-			]
-		}));
-	}
-	return {
-		kind: "index",
-		id: stableId$2(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		unique: number$2(first.non_unique) === 0,
-		terms,
-		method: text$2(first.index_type),
-		dialect: mysqlExtension({
-			...text$2(first.index_type) === void 0 ? {} : { indexType: text$2(first.index_type) },
-			...text$2(first.is_visible) === void 0 ? {} : { visible: text$2(first.is_visible).toUpperCase() !== "NO" },
-			...text$2(first.comment) === void 0 ? {} : { comment: text$2(first.comment) },
-			...text$2(first.index_comment) === void 0 ? {} : { indexComment: text$2(first.index_comment) }
-		}),
-		reference: reference$2("index", physicalName, namespace, "INFORMATION_SCHEMA.STATISTICS", "INDEX_NAME")
-	};
-}
-function viewObject$1(tableRow, viewRow, namespace, diagnostics) {
-	const physicalName = text$2(tableRow.table_name) ?? "unnamed_view";
-	const physicalReference = reference$2("view", physicalName, namespace, "INFORMATION_SCHEMA.VIEWS", "TABLE_NAME");
-	const definition = text$2(viewRow?.view_definition);
-	if (definition === void 0 || definition.trim() === "") {
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "expression-parse-failed",
-			message: `MySQL view ${physicalName} has no recoverable definition`,
-			path: [
-				"views",
-				physicalName,
-				"definition"
-			],
-			physicalReference,
-			remediation: "Grant the metadata privilege needed to read INFORMATION_SCHEMA.VIEWS.VIEW_DEFINITION."
-		}));
-		return {
-			kind: "deferred-object",
-			id: stableId$2(`view:${physicalName}`),
-			identitySource: "physical-name",
-			objectKind: "view",
-			physicalName,
-			reference: physicalReference,
-			dialect: mysqlExtension({
-				reason: "definition-unavailable",
-				...text$2(viewRow?.definer) === void 0 ? {} : { definer: text$2(viewRow?.definer) }
-			})
-		};
-	}
-	const checkOption = normalizeCheckOption(viewRow?.check_option);
-	const securityType = text$2(viewRow?.security_type)?.toUpperCase();
-	return {
-		kind: "view",
-		id: stableId$2(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		columns: [],
-		definition: sql$2(definition, namespace, {
-			kind: "view",
-			physicalName,
-			reference: physicalReference
-		}, physicalName),
-		...checkOption === void 0 ? {} : { checkOption },
-		...securityType === "INVOKER" ? { securityInvoker: true } : {},
-		reference: physicalReference,
-		provenance: {
-			kind: "catalog",
-			dialect: "mysql",
-			reference: physicalReference
-		},
-		dialect: mysqlExtension({
-			...text$2(viewRow?.is_updatable) === void 0 ? {} : { isUpdatable: text$2(viewRow?.is_updatable) },
-			...securityType === void 0 ? {} : { securityType },
-			...text$2(viewRow?.definer) === void 0 ? {} : { definer: text$2(viewRow?.definer) }
-		})
-	};
-}
-function routineObject(row, parameterRows, namespace) {
-	const physicalName = text$2(row.routine_name) ?? "unnamed_routine";
-	const physicalReference = reference$2("routine", physicalName, namespace, "INFORMATION_SCHEMA.ROUTINES", "ROUTINE_NAME");
-	const parameters = parameterRows.filter((row) => (number$2(row.ordinal_position) ?? 0) > 0).sort((left, right) => (number$2(left.ordinal_position) ?? 0) - (number$2(right.ordinal_position) ?? 0)).map(routineParameter);
-	const definition = text$2(row.routine_definition);
-	const returnType = text$2(row.data_type);
-	const routine = {
-		kind: "routine",
-		id: stableId$2(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		routineKind: text$2(row.routine_type)?.toUpperCase() === "FUNCTION" ? "function" : text$2(row.routine_type)?.toUpperCase() === "PROCEDURE" ? "procedure" : "unknown",
-		parameters,
-		...returnType === void 0 || returnType.toUpperCase() === "VOID" ? {} : { returnType: storage$1(row.data_type, row.dtd_identifier) },
-		...text$2(row.external_language) === void 0 && text$2(row.routine_body) === void 0 ? {} : { language: text$2(row.external_language) ?? text$2(row.routine_body) ?? "unknown" },
-		...definition === void 0 ? {} : { body: sql$2(definition, namespace, {
-			kind: "routine",
-			physicalName,
-			reference: physicalReference
-		}, physicalName) },
-		volatility: "unknown",
-		...text$2(row.security_type) === void 0 ? {} : { security: routineSecurity(row.security_type) },
-		reference: physicalReference,
-		provenance: {
-			kind: "catalog",
-			dialect: "mysql",
-			reference: physicalReference
-		},
-		dialect: mysqlExtension({
-			...text$2(row.is_deterministic) === void 0 ? {} : { deterministic: text$2(row.is_deterministic).toUpperCase() === "YES" },
-			...text$2(row.sql_data_access) === void 0 ? {} : { sqlDataAccess: text$2(row.sql_data_access) },
-			...text$2(row.sql_mode) === void 0 ? {} : { sqlMode: text$2(row.sql_mode) }
-		})
-	};
-	const commentText = text$2(row.routine_comment);
-	if (commentText === void 0 || commentText === "") return routine;
-	return {
-		...routine,
-		comment: objectComment({
-			kind: "routine",
-			id: routine.id
-		}, commentText, physicalReference, namespace)
-	};
-}
-function routineParameter(row) {
-	const parameterName = text$2(row.parameter_name);
-	return {
-		...parameterName === void 0 ? {} : { name: parameterName },
-		...routineParameterMode$1(row.parameter_mode) === void 0 ? {} : { mode: routineParameterMode$1(row.parameter_mode) },
-		storage: storage$1(row.data_type, row.dtd_identifier),
-		ordinalPosition: number$2(row.ordinal_position) ?? 0
-	};
-}
-function triggerObject$1(rows, relations, namespace, diagnostics) {
-	const first = rows[0];
-	const physicalName = text$2(first.trigger_name) ?? "unnamed_trigger";
-	const physicalReference = reference$2("trigger", physicalName, namespace, "INFORMATION_SCHEMA.TRIGGERS", "TRIGGER_NAME");
-	const tableName = text$2(first.table_name);
-	const target = tableName === void 0 ? void 0 : relations.get(tableName);
-	const body = text$2(first.action_statement);
-	if (target === void 0 || body === void 0 || body.trim() === "") {
-		if (target === void 0) diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "unresolved-reference",
-			message: `MySQL trigger ${physicalName} target ${tableName ?? "unknown"} was not found`,
-			path: [
-				"triggers",
-				physicalName,
-				"table"
-			],
-			physicalReference
-		}));
-		if (body === void 0 || body.trim() === "") diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "expression-parse-failed",
-			message: `MySQL trigger ${physicalName} has no recoverable body`,
-			path: [
-				"triggers",
-				physicalName,
-				"body"
-			],
-			physicalReference
-		}));
-		return {
-			kind: "deferred-object",
-			id: stableId$2(`trigger:${physicalName}`),
-			identitySource: "physical-name",
-			objectKind: "trigger",
-			physicalName,
-			reference: physicalReference,
-			dialect: mysqlExtension({
-				...tableName === void 0 ? {} : { tableName },
-				...body === void 0 ? {} : { actionStatement: body }
-			})
-		};
-	}
-	const timing = triggerTiming$1(first.action_timing);
-	const events = [...new Set(rows.map((row) => triggerEvent(row.event_manipulation)).filter((value) => value !== void 0))];
-	return {
-		kind: "trigger",
-		id: stableId$2(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		table: target,
-		timing,
-		events,
-		orientation: triggerOrientation(first.action_orientation),
-		...text$2(first.action_condition) === void 0 ? {} : { condition: sql$2(text$2(first.action_condition), namespace, {
-			kind: "trigger",
-			physicalName,
-			reference: physicalReference
-		}, physicalName) },
-		body: sql$2(body, namespace, {
-			kind: "trigger",
-			physicalName,
-			reference: physicalReference
-		}, physicalName),
-		reference: physicalReference,
-		provenance: {
-			kind: "catalog",
-			dialect: "mysql",
-			reference: physicalReference
-		},
-		dialect: mysqlExtension({
-			...text$2(first.definer) === void 0 ? {} : { definer: text$2(first.definer) },
-			...text$2(first.sql_mode) === void 0 ? {} : { sqlMode: text$2(first.sql_mode) },
-			...number$2(first.action_order) === void 0 ? {} : { actionOrder: number$2(first.action_order) }
-		})
-	};
-}
-function partitionObject$1(row, tables, namespace, diagnostics) {
-	const tableName = text$2(row.table_name) ?? "unknown";
-	const partitionName = text$2(row.partition_name);
-	const subpartitionName = text$2(row.subpartition_name);
-	const physicalName = partitionName === void 0 ? tableName : subpartitionName === void 0 ? partitionName : `${partitionName}/${subpartitionName}`;
-	const physicalReference = reference$2("partition", physicalName, namespace, "INFORMATION_SCHEMA.PARTITIONS", "PARTITION_NAME");
-	const parent = tables.get(tableName);
-	if (parent === void 0) {
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "unresolved-reference",
-			message: `MySQL partition ${physicalName} parent table ${tableName} was not found`,
-			path: [
-				"partitions",
-				physicalName,
-				"parent"
-			],
-			physicalReference
-		}));
-		return {
-			kind: "deferred-object",
-			id: stableId$2(`partition:${tableName}:${physicalName}`),
-			identitySource: "physical-name",
-			objectKind: "partition",
-			physicalName,
-			reference: physicalReference,
-			dialect: mysqlExtension({ tableName })
-		};
-	}
-	const method = text$2(row.subpartition_method) ?? text$2(row.partition_method) ?? "UNKNOWN";
-	const strategy = partitionStrategy$1(method);
-	if (strategy === "unknown") diagnostics.push(createIntrospectionDiagnostic({
-		severity: "warning",
-		code: "unsupported-feature",
-		message: `MySQL partition method ${method} is retained with an unknown normalized strategy`,
-		path: [
-			"partitions",
-			physicalName,
-			"strategy"
-		],
-		physicalReference
-	}));
-	const boundText = text$2(row.partition_description) ?? text$2(row.subpartition_expression) ?? text$2(row.partition_expression);
-	const expression = text$2(row.partition_expression);
-	const partition = {
-		kind: "partition",
-		id: stableId$2(`partition:${tableName}:${physicalName}`),
-		identitySource: "physical-name",
-		physicalName,
-		parent: {
-			kind: "table",
-			id: parent.id
-		},
-		strategy,
-		...expression === void 0 ? {} : { keyColumns: partitionKeyColumns$1(expression) },
-		...boundText === void 0 ? {} : { bound: sql$2(boundText, namespace, parent, physicalName) },
-		reference: physicalReference,
-		dialect: mysqlExtension({
-			...text$2(row.partition_method) === void 0 ? {} : { partitionMethod: text$2(row.partition_method) },
-			...text$2(row.subpartition_method) === void 0 ? {} : { subpartitionMethod: text$2(row.subpartition_method) },
-			...text$2(row.subpartition_name) === void 0 ? {} : { subpartitionName: text$2(row.subpartition_name) },
-			...text$2(row.tablespace_name) === void 0 ? {} : { tablespace: text$2(row.tablespace_name) }
-		})
-	};
-	const commentText = text$2(row.partition_comment);
-	if (commentText === void 0 || commentText === "") return partition;
-	return {
-		...partition,
-		comment: objectComment({
-			kind: "partition",
-			id: partition.id
-		}, commentText, physicalReference, namespace)
-	};
-}
-function collationObject$1(row, namespace) {
-	const physicalName = text$2(row.collation_name) ?? "unknown_collation";
-	return {
-		kind: "collation",
-		id: stableId$2(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		reference: reference$2("collation", physicalName, namespace, "INFORMATION_SCHEMA.COLLATIONS", "COLLATION_NAME"),
-		dialect: mysqlExtension({
-			...text$2(row.character_set_name) === void 0 ? {} : { characterSet: text$2(row.character_set_name) },
-			...number$2(row.collation_id) === void 0 ? {} : { id: number$2(row.collation_id) },
-			...text$2(row.is_default) === void 0 ? {} : { isDefault: text$2(row.is_default) === "Yes" },
-			...text$2(row.is_compiled) === void 0 ? {} : { isCompiled: text$2(row.is_compiled) === "Yes" },
-			...number$2(row.sort_length) === void 0 ? {} : { sortLength: number$2(row.sort_length) },
-			...text$2(row.pad_attribute) === void 0 ? {} : { padAttribute: text$2(row.pad_attribute) }
-		})
-	};
-}
-function opaqueEvent(row, namespace) {
-	const physicalName = text$2(row.event_name) ?? "unnamed_event";
-	const physicalReference = reference$2("opaque-object", physicalName, namespace, "INFORMATION_SCHEMA.EVENTS", "EVENT_NAME");
-	const definition = text$2(row.event_definition) ?? text$2(row.event_body);
-	return {
-		kind: "opaque-object",
-		id: stableId$2(`event:${physicalName}`),
-		identitySource: "physical-name",
-		objectKind: "event",
-		physicalName,
-		data: {
-			...text$2(row.event_type) === void 0 ? {} : { eventType: text$2(row.event_type) },
-			...text$2(row.status) === void 0 ? {} : { status: text$2(row.status) },
-			...text$2(row.execute_at) === void 0 ? {} : { executeAt: text$2(row.execute_at) },
-			...text$2(row.interval_value) === void 0 ? {} : { intervalValue: text$2(row.interval_value) },
-			...text$2(row.interval_field) === void 0 ? {} : { intervalField: text$2(row.interval_field) },
-			...text$2(row.definer) === void 0 ? {} : { definer: text$2(row.definer) }
-		},
-		...definition === void 0 ? {} : { sql: sql$2(definition, namespace, {
-			kind: "opaque-object",
-			physicalName,
-			reference: physicalReference
-		}, physicalName) },
-		reference: physicalReference,
-		provenance: {
-			kind: "catalog",
-			dialect: "mysql",
-			reference: physicalReference
-		},
-		dialect: mysqlExtension({ objectKind: "event" })
-	};
-}
-function objectComment(object, comment, physicalReference, namespace) {
-	return {
-		kind: "comment",
-		id: stableId$2(`${object.kind}_${object.id}_comment`),
-		object,
-		text: comment,
-		reference: physicalReference,
-		provenance: {
-			kind: "catalog",
-			dialect: "mysql",
-			reference: physicalReference,
-			path: ["namespace", namespace]
-		}
-	};
-}
-function groupRows(rows, keyOf) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const key = keyOf(row);
-		const group = groups.get(key) ?? [];
-		group.push(row);
-		groups.set(key, group);
-	}
-	return [...groups.entries()].sort(([left], [right]) => left.localeCompare(right)).map(([, group]) => group);
-}
-function mysqlExtension(data) {
-	return {
-		dialect: "mysql",
-		version: 1,
-		data
-	};
-}
-function storage$1(dataType, declaration) {
-	return { nativeType: text$2(declaration) ?? text$2(dataType) ?? "unknown" };
-}
-function normalizeCheckOption(value) {
-	const normalized = text$2(value)?.toLowerCase();
-	return normalized === "none" || normalized === void 0 ? normalized === void 0 ? void 0 : "none" : normalized === "local" ? "local" : normalized === "cascaded" ? "cascaded" : void 0;
-}
-function routineSecurity(value) {
-	return text$2(value)?.toLowerCase() === "invoker" ? "invoker" : text$2(value)?.toLowerCase() === "definer" ? "definer" : "unknown";
-}
-function routineParameterMode$1(value) {
-	const normalized = text$2(value)?.toLowerCase();
-	return normalized === "in" ? "in" : normalized === "out" ? "out" : normalized === "inout" ? "inout" : void 0;
-}
-function triggerTiming$1(value) {
-	const normalized = text$2(value)?.toLowerCase();
-	return normalized === "before" ? "before" : normalized === "after" ? "after" : "unknown";
-}
-function triggerEvent(value) {
-	const normalized = text$2(value)?.toLowerCase();
-	return normalized === "insert" || normalized === "update" || normalized === "delete" ? normalized : void 0;
-}
-function triggerOrientation(value) {
-	const normalized = text$2(value)?.toLowerCase();
-	return normalized === "row" ? "row" : normalized === "statement" ? "statement" : void 0;
-}
-function partitionStrategy$1(value) {
-	const normalized = value.toLowerCase();
-	return normalized === "range" ? "range" : normalized === "list" ? "list" : normalized === "hash" ? "hash" : "unknown";
-}
-function partitionKeyColumns$1(expression) {
-	return expression.split(",").map((value) => value.trim()).filter((value) => /^[A-Za-z_][A-Za-z0-9_$]*$/.test(value));
-}
-function sql$2(textValue, namespace, table, name) {
-	return {
-		kind: "sql",
-		dialect: "mysql",
-		text: textValue,
-		provenance: {
-			kind: "catalog",
-			dialect: "mysql",
-			reference: table.reference ?? reference$2(table.kind, name, namespace, "INFORMATION_SCHEMA", "TABLE_NAME", table.physicalName)
-		}
-	};
-}
-function reference$2(kind, name, namespace, relation, key, value = name) {
-	return {
-		kind,
-		name,
-		namespace,
-		catalog: {
-			relation,
-			key,
-			value
-		}
-	};
-}
-function literal(value, dataType) {
-	if (value === void 0) return;
-	if (value.toUpperCase() === "NULL") return null;
-	if (value.toUpperCase() === "TRUE") return true;
-	if (value.toUpperCase() === "FALSE") return false;
-	if (/^-?(?:\d+\.?\d*|\.\d+)$/.test(value)) return Number(value);
-	if (/^'(?:''|[^'])*'$/.test(value)) return value.slice(1, -1).replace(/''/g, "'");
-	if (value === "" || /^(?:char|varchar|text|tinytext|mediumtext|longtext|enum|set)$/i.test(dataType ?? "")) return value;
-}
-function emptyCatalog$2(namespace, diagnostics) {
-	return {
-		dialect: "mysql",
-		server: {
-			product: "mysql",
-			rawVersion: "unknown",
-			capabilities: {
-				generatedColumns: false,
-				identityMetadata: false,
-				checkConstraints: false,
-				checkConstraintEnforcement: "unknown",
-				expressionDecompilation: false,
-				indexExpressions: false,
-				indexPredicates: false,
-				indexIncludedColumns: false,
-				namespaces: true,
-				visibility: "unknown"
-			}
-		},
-		namespace: {
-			kind: "mysql-database",
-			name: namespace
-		},
-		tables: [],
-		deferredObjects: [],
-		diagnostics
-	};
-}
-function stableId$2(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$2(value) {
-	return value === null || value === void 0 ? void 0 : String(value);
-}
-function number$2(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 action$1(value) {
-	const normalized = text$2(value)?.toLowerCase();
-	return normalized === "cascade" ? "cascade" : normalized === "restrict" ? "restrict" : normalized === "set null" ? "set-null" : normalized === "set default" ? "set-default" : "no-action";
-}
-function match$1(value) {
-	return text$2(value)?.toLowerCase() === "full" ? "full" : "simple";
-}
-//#endregion
-//#region src/introspection/postgres.ts
-/** Fixed server metadata query used by the PostgreSQL catalog reader. */
-const postgresServerQuery = `
-  SELECT
-    current_setting('server_version_num') AS server_version_num,
-    current_setting('server_version') AS server_version
-`;
-/** Read one PostgreSQL schema into the normalized catalog contract. */
-async function readPostgresCatalog(connection, options) {
-	const diagnostics = [];
-	if (connection.dialect !== "postgresql") {
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "dialect-mismatch",
-			message: `PostgreSQL catalog reader received a ${connection.dialect} connection`,
-			path: ["connection", "dialect"],
-			remediation: "Use a PostgreSQL CatalogConnection with this reader."
-		}));
-		return emptyCatalog$1(options.namespace, diagnostics);
-	}
-	const server = serverInfo$1((await query$1(connection, postgresServerQuery, [], options, diagnostics, "server"))[0], diagnostics);
-	const relationObjects = (await query$1(connection, postgresRelationsQuery, [options.namespace], options, diagnostics, "relations")).filter((row) => {
-		const kind = text$1(row.relkind);
-		return kind !== "i" && kind !== "I";
-	});
-	const tables = relationObjects.filter((row) => row.relkind === "r" || row.relkind === "p").map((row) => relationTable(row));
-	const tableByOid = new Map(tables.map((table) => [table.reference?.catalog?.value, table]));
-	const viewRows = await query$1(connection, postgresViewsQuery, [options.namespace], options, diagnostics, "views");
-	const views = [];
-	for (const row of viewRows) {
-		const view = viewObject(row, options.namespace, diagnostics);
-		if (view.kind === "deferred-object") continue;
-		views.push(view);
-	}
-	const relationReferences = /* @__PURE__ */ new Map();
-	for (const table of tables) relationReferences.set(table.reference?.catalog?.value, {
-		kind: "table",
-		id: table.id
-	});
-	for (const view of views) relationReferences.set(view.reference?.catalog?.value, {
-		kind: view.kind,
-		id: view.id
-	});
-	const columnRows = await query$1(connection, postgresColumnsQuery, [options.namespace], options, diagnostics, "columns");
-	const identityRows = await query$1(connection, postgresIdentitiesQuery, [options.namespace], options, diagnostics, "identities");
-	const identityOptionsByColumn = /* @__PURE__ */ new Map();
-	for (const row of identityRows) identityOptionsByColumn.set(columnKey(row.table_oid, row.ordinal_position), identityOptions(row));
-	const columnsByTable = groupBy(columnRows, (row) => row.table_oid);
-	for (const table of tables) table.columns = (columnsByTable.get(table.reference?.catalog?.value) ?? []).sort(compareOrdinal).map((row) => column$1(row, table, options.namespace, identityOptionsByColumn.get(columnKey(row.table_oid, row.ordinal_position))));
-	for (const view of views) view.columns = (columnsByTable.get(view.reference?.catalog?.value) ?? []).sort(compareOrdinal).map((row) => column$1(row, view, options.namespace));
-	const indexRows = await query$1(connection, postgresIndexesQuery, [options.namespace], options, diagnostics, "indexes");
-	const indexReferences = /* @__PURE__ */ new Map();
-	for (const row of indexRows) {
-		const indexOid = text$1(row.index_oid);
-		const physicalName = text$1(row.physical_name);
-		if (indexOid && physicalName) indexReferences.set(`pg_class:${indexOid}`, {
-			kind: "index",
-			id: stableId$1(physicalName),
-			physicalName,
-			reference: reference$1("index", physicalName, options.namespace, "pg_class", "oid", row.index_oid)
-		});
-	}
-	const constraintsByTable = groupBy(await query$1(connection, postgresConstraintsQuery, [options.namespace], options, diagnostics, "constraints"), (row) => row.table_oid);
-	for (const table of tables) {
-		const rows = constraintsByTable.get(table.reference?.catalog?.value) ?? [];
-		const columnsByNumber = new Map(table.columns.map((column) => [column.ordinalPosition, column.physicalName]));
-		table.constraints = rows.map((row) => constraint(row, table, columnsByNumber, tableByOid, options.namespace, diagnostics, indexReferences)).filter((value) => value !== void 0);
-	}
-	const indexesByTable = groupBy(indexRows, (row) => row.table_oid);
-	for (const table of tables) table.indexes = mapIndexes(indexesByTable.get(table.reference?.catalog?.value) ?? [], table, new Map(table.columns.map((column) => [column.ordinalPosition, column.physicalName])), options.namespace);
-	const sequences = (await query$1(connection, postgresSequencesQuery, [options.namespace], options, diagnostics, "sequences")).map((row) => sequenceObject(row, options.namespace, tableByOid, diagnostics));
-	const enums = mapEnums(await query$1(connection, postgresEnumsQuery, [options.namespace], options, diagnostics, "enums"), options.namespace);
-	const domains = mapDomains(await query$1(connection, postgresDomainsQuery, [options.namespace], options, diagnostics, "domains"), await query$1(connection, postgresDomainConstraintsQuery, [options.namespace], options, diagnostics, "domain-constraints"), options.namespace);
-	const collations = (await query$1(connection, postgresCollationsQuery, [options.namespace], options, diagnostics, "collations")).map((row) => collationObject(row, options.namespace));
-	const triggerRows = await query$1(connection, postgresTriggersQuery, [options.namespace], options, diagnostics, "triggers");
-	const triggers = [];
-	const triggerDeferredObjects = [];
-	for (const row of triggerRows) {
-		const value = triggerObject(row, options.namespace, relationReferences, diagnostics);
-		if (value.kind === "deferred-object") triggerDeferredObjects.push(value);
-		else triggers.push(value);
-	}
-	const routines = mapRoutines(await query$1(connection, postgresRoutinesQuery, [options.namespace], options, diagnostics, "routines"), await query$1(connection, postgresRoutineParametersQuery, [options.namespace], options, diagnostics, "routine-parameters"), options.namespace, diagnostics);
-	const partitions = (await query$1(connection, postgresPartitionsQuery, [options.namespace], options, diagnostics, "partitions")).map((row) => partitionObject(row, options.namespace, tableByOid, diagnostics)).filter((value) => value !== void 0);
-	const policies = (await query$1(connection, postgresPoliciesQuery, [options.namespace], options, diagnostics, "policies")).map((row) => policyObject(row, options.namespace, tableByOid, diagnostics)).filter((value) => value !== void 0);
-	const extensionObjects = (await query$1(connection, postgresExtensionsQuery, [options.namespace], options, diagnostics, "extensions")).map((row) => extensionObject(row, options.namespace));
-	const typedRelationOids = new Set([...views, ...sequences].map((object) => object.reference?.catalog?.value));
-	const deferredObjects = relationObjects.filter((row) => {
-		const relkind = text$1(row.relkind);
-		return relkind === "f" || (relkind === "v" || relkind === "m" || relkind === "S") && !typedRelationOids.has(row.oid === void 0 ? void 0 : text$1(row.oid));
-	}).map((row) => deferredObject(row, text$1(row.relkind) === "f" ? "foreign-table" : text$1(row.relkind) === "v" ? "view" : text$1(row.relkind) === "m" ? "materialized-view" : "sequence"));
-	deferredObjects.push(...triggerDeferredObjects);
-	const opaqueObjects = relationObjects.filter((row) => {
-		const kind = text$1(row.relkind);
-		return kind !== "r" && kind !== "p" && kind !== "v" && kind !== "m" && kind !== "S" && kind !== "f";
-	}).map((row) => opaqueRelationObject(row, options.namespace, diagnostics));
-	const metadata = mapMetadataRows(await query$1(connection, postgresMetadataQuery, [options.namespace], options, diagnostics, "comments-and-ownership"), options.namespace, tables, views, sequences, enums, domains, collations, routines, triggers, policies, extensionObjects, deferredObjects, opaqueObjects, indexReferences, relationReferences, diagnostics);
-	opaqueObjects.push(...metadata.opaqueObjects);
-	return Object.freeze({
-		dialect: "postgresql",
-		server,
-		namespace: {
-			kind: "postgres-schema",
-			name: options.namespace,
-			reference: reference$1("namespace", options.namespace, options.namespace, "pg_namespace", "nspname")
-		},
-		tables: Object.freeze(tables),
-		views: Object.freeze(views),
-		sequences: Object.freeze(sequences),
-		enums: Object.freeze(enums),
-		domains: Object.freeze(domains),
-		collations: Object.freeze(collations),
-		triggers: Object.freeze(triggers),
-		routines: Object.freeze(routines),
-		partitions: Object.freeze(partitions),
-		policies: Object.freeze(policies),
-		extensionObjects: Object.freeze(extensionObjects),
-		deferredObjects: Object.freeze(deferredObjects),
-		opaqueObjects: Object.freeze(opaqueObjects),
-		comments: Object.freeze(metadata.comments),
-		ownership: Object.freeze(metadata.ownership),
-		capabilities: server.capabilities,
-		diagnostics: Object.freeze(diagnostics)
-	});
-}
-const postgresRelationsQuery = `
-  SELECT c.oid::text AS oid, n.nspname AS namespace, c.relname,
-         c.relkind, c.relispartition
-  FROM pg_class c
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  WHERE n.nspname = $1
-    AND c.relkind NOT IN ('i', 'I')
-  ORDER BY c.relname
-`;
-/** Fixed view and materialized-view definitions from PostgreSQL's decompiler. */
-const postgresViewsQuery = `
-  SELECT c.oid::text AS oid, n.nspname AS namespace, c.relname AS physical_name,
-         c.relkind, pg_get_viewdef(c.oid, true) AS definition,
-         v.check_option, c.reloptions
-  FROM pg_catalog.pg_class c
-  JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-  LEFT JOIN information_schema.views v
-    ON v.table_schema = n.nspname AND v.table_name = c.relname
-  WHERE n.nspname = $1 AND c.relkind IN ('v', 'm')
-  ORDER BY c.oid
-`;
-const postgresColumnsQuery = `
-  SELECT a.attrelid::text AS table_oid, a.attnum::int AS ordinal_position,
-         a.attname AS physical_name, NOT a.attnotnull AS nullable,
-         format_type(a.atttypid, a.atttypmod) AS native_type,
-         a.attidentity, a.attgenerated,
-         pg_get_expr(ad.adbin, ad.adrelid) AS default_expression
-  FROM pg_attribute a
-  JOIN pg_class c ON c.oid = a.attrelid
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  LEFT JOIN pg_attrdef ad ON ad.adrelid = a.attrelid AND ad.adnum = a.attnum
-  WHERE n.nspname = $1
-    AND c.relkind IN ('r', 'p', 'v', 'm')
-    AND a.attnum > 0
-    AND NOT a.attisdropped
-  ORDER BY a.attrelid, a.attnum
-`;
-const postgresConstraintsQuery = `
-  SELECT con.oid::text AS oid, con.conrelid::text AS table_oid,
-         con.conname AS physical_name, con.contype,
-         con.conkey, con.confrelid::text AS target_table_oid, con.confkey,
-         con.confupdtype, con.confdeltype, con.confmatchtype,
-         con.condeferrable, con.condeferred, con.convalidated,
-         con.conindid::text AS backing_index_oid,
-         i.indnullsnotdistinct,
-         pg_get_constraintdef(con.oid, true) AS definition
-  FROM pg_constraint con
-  JOIN pg_class c ON c.oid = con.conrelid
-  JOIN pg_namespace n ON n.oid = c.relnamespace
-  LEFT JOIN pg_index i ON i.indexrelid = con.conindid
-  WHERE n.nspname = $1
-    AND con.contype IN ('p', 'u', 'f', 'c', 'x')
-  ORDER BY con.conrelid, con.oid
-`;
-const postgresIndexesQuery = `
-  SELECT i.indexrelid::text AS index_oid, i.indrelid::text AS table_oid,
-         c.relname AS physical_name, i.indisunique, i.indnkeyatts::int,
-         i.indnatts::int, am.amname AS method,
-         pg_get_expr(i.indpred, i.indrelid, true) AS predicate,
-         s.position::int,
-         (i.indkey[s.position])::int AS attnum,
-         (i.indoption[s.position])::int AS indoption,
-         opc.opcname AS operator_class,
-         pg_get_indexdef(i.indexrelid, s.position, true) AS term_definition
-  FROM pg_index i
-  JOIN pg_class c ON c.oid = i.indexrelid
-  JOIN pg_class t ON t.oid = i.indrelid
-  JOIN pg_namespace n ON n.oid = t.relnamespace
-  JOIN pg_am am ON am.oid = c.relam
-  CROSS JOIN LATERAL generate_series(1, i.indnatts) AS s(position)
-  LEFT JOIN pg_opclass opc ON opc.oid = i.indclass[s.position]
-  WHERE n.nspname = $1
-  ORDER BY i.indrelid, i.indexrelid, s.position
-`;
-/** Identity sequence options joined to each generated identity column. */
-const postgresIdentitiesQuery = `
-  SELECT a.attrelid::text AS table_oid, a.attnum::int AS ordinal_position,
-         s.seqstart, s.seqincrement, s.seqmin, s.seqmax, s.seqcache,
-         s.seqcycle, format_type(s.seqtypid, -1) AS sequence_type
-  FROM pg_catalog.pg_attribute a
-  JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
-  JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-  JOIN pg_catalog.pg_depend d
-    ON d.refclassid = 'pg_catalog.pg_class'::regclass
-   AND d.refobjid = a.attrelid AND d.refobjsubid = a.attnum
-   AND d.classid = 'pg_catalog.pg_class'::regclass
-   AND d.deptype = 'i'
-  JOIN pg_catalog.pg_sequence s ON s.seqrelid = d.objid
-  WHERE n.nspname = $1 AND a.attidentity <> ''
-  ORDER BY a.attrelid, a.attnum
-`;
-/** Sequence metadata, including serial/identity ownership dependencies. */
-const postgresSequencesQuery = `
-  SELECT c.oid::text AS oid, n.nspname AS namespace, c.relname AS physical_name,
-         format_type(s.seqtypid, -1) AS native_type,
-         s.seqstart, s.seqincrement, s.seqmin, s.seqmax, s.seqcache,
-         s.seqcycle, dep.refobjid::text AS owned_table_oid,
-         dep.refobjsubid::int AS owned_column_position
-  FROM pg_catalog.pg_sequence s
-  JOIN pg_catalog.pg_class c ON c.oid = s.seqrelid
-  JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-  LEFT JOIN pg_catalog.pg_depend dep
-    ON dep.classid = 'pg_catalog.pg_class'::regclass
-   AND dep.objid = c.oid AND dep.refclassid = 'pg_catalog.pg_class'::regclass
-   AND dep.deptype IN ('a', 'i')
-  WHERE n.nspname = $1
-  ORDER BY c.oid
-`;
-/** PostgreSQL enum labels in their declared order. */
-const postgresEnumsQuery = `
-  SELECT t.oid::text AS oid, n.nspname AS namespace,
-         t.typname AS physical_name, e.oid::text AS value_oid,
-         e.enumlabel AS value, e.enumsortorder::float8 AS ordinal_position
-  FROM pg_catalog.pg_type t
-  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-  JOIN pg_catalog.pg_enum e ON e.enumtypid = t.oid
-  WHERE n.nspname = $1 AND t.typtype = 'e'
-  ORDER BY t.oid, e.enumsortorder
-`;
-/** PostgreSQL domains and their exact base type/default metadata. */
-const postgresDomainsQuery = `
-  SELECT t.oid::text AS oid, n.nspname AS namespace,
-         t.typname AS physical_name,
-         format_type(t.typbasetype, t.typtypmod) AS native_type,
-         NOT t.typnotnull AS nullable, t.typdefault AS default_expression
-  FROM pg_catalog.pg_type t
-  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-  WHERE n.nspname = $1 AND t.typtype = 'd'
-  ORDER BY t.oid
-`;
-/** Domain CHECK constraints, which use pg_constraint.contypid. */
-const postgresDomainConstraintsQuery = `
-  SELECT con.oid::text AS oid, con.contypid::text AS domain_oid,
-         con.conname AS physical_name, pg_get_constraintdef(con.oid, true) AS definition,
-         con.condeferrable, con.condeferred, con.convalidated
-  FROM pg_catalog.pg_constraint con
-  JOIN pg_catalog.pg_type t ON t.oid = con.contypid
-  JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-  WHERE n.nspname = $1 AND con.contype = 'c'
-  ORDER BY con.contypid, con.oid
-`;
-/** Collation provider, locale, determinism, and version facts. */
-const postgresCollationsQuery = `
-  SELECT c.oid::text AS oid, n.nspname AS namespace,
-         c.collname AS physical_name, c.collprovider, c.collcollate,
-         c.collctype, to_jsonb(c)->>'colllocale' AS colliculocale,
-         c.collisdeterministic, c.collversion
-  FROM pg_catalog.pg_collation c
-  JOIN pg_catalog.pg_namespace n ON n.oid = c.collnamespace
-  WHERE n.nspname = $1
-  ORDER BY c.oid
-`;
-/** User-defined triggers with decompiled condition and definition text. */
-const postgresTriggersQuery = `
-  SELECT t.oid::text AS oid, t.tgrelid::text AS table_oid,
-         n.nspname AS namespace, t.tgname AS physical_name,
-         t.tgtype::int AS trigger_type, t.tgenabled,
-         pg_get_expr(t.tgqual, t.tgrelid, true) AS condition,
-         pg_get_triggerdef(t.oid, true) AS definition
-  FROM pg_catalog.pg_trigger t
-  JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid
-  JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-  WHERE n.nspname = $1 AND NOT t.tgisinternal
-  ORDER BY t.tgrelid, t.oid
-`;
-/** PostgreSQL functions, procedures, aggregates, and window routines. */
-const postgresRoutinesQuery = `
-  SELECT p.oid::text AS oid, n.nspname AS namespace,
-         p.proname AS physical_name, p.prokind,
-         format_type(p.prorettype, NULL) AS return_type,
-         l.lanname AS language, pg_get_functiondef(p.oid) AS definition,
-         pg_get_function_identity_arguments(p.oid) AS identity_arguments,
-         pg_get_expr(p.proargdefaults, 0, true) AS argument_defaults,
-         p.pronargdefaults, p.provolatile, p.proparallel, p.prosecdef
-  FROM pg_catalog.pg_proc p
-  JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-  JOIN pg_catalog.pg_language l ON l.oid = p.prolang
-  WHERE n.nspname = $1 AND p.prokind IN ('f', 'p', 'a', 'w')
-  ORDER BY p.oid
-`;
-/** Routine parameter rows using PostgreSQL's complete argument type arrays. */
-const postgresRoutineParametersQuery = `
-  SELECT p.oid::text AS routine_oid, x.position::int AS ordinal_position,
-         names.name AS parameter_name, modes.mode,
-         format_type(x.type_oid, -1) AS native_type
-  FROM pg_catalog.pg_proc p
-  JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-  CROSS JOIN LATERAL unnest(
-    COALESCE(p.proallargtypes, p.proargtypes::oid[])
-  ) WITH ORDINALITY AS x(type_oid, position)
-  LEFT JOIN LATERAL unnest(p.proargnames) WITH ORDINALITY
-    AS names(name, position) ON names.position = x.position
-  LEFT JOIN LATERAL unnest(p.proargmodes) WITH ORDINALITY
-    AS modes(mode, position) ON modes.position = x.position
-  WHERE n.nspname = $1 AND p.prokind IN ('f', 'p', 'a', 'w')
-  ORDER BY p.oid, x.position
-`;
-/** Partition children, key attributes, strategy, and bound expression. */
-const postgresPartitionsQuery = `
-  SELECT child.oid::text AS partition_oid, parent.oid::text AS parent_oid,
-         n.nspname AS namespace, child.relname AS physical_name,
-         part.partstrat, part.partattrs::text AS key_attributes,
-         pg_get_expr(child.relpartbound, child.oid, true) AS bound,
-         child.relispartition, child.relkind
-  FROM pg_catalog.pg_inherits inh
-  JOIN pg_catalog.pg_class child ON child.oid = inh.inhrelid
-  JOIN pg_catalog.pg_class parent ON parent.oid = inh.inhparent
-  JOIN pg_catalog.pg_namespace n ON n.oid = child.relnamespace
-  LEFT JOIN pg_catalog.pg_partitioned_table part ON part.partrelid = parent.oid
-  WHERE n.nspname = $1
-  ORDER BY parent.oid, child.oid
-`;
-/** Row-level security policies and their role/expression metadata. */
-const postgresPoliciesQuery = `
-  SELECT p.oid::text AS oid, p.polrelid::text AS table_oid,
-         n.nspname AS namespace, p.polname AS physical_name,
-         p.polcmd, p.polpermissive,
-         ARRAY(SELECT r.rolname FROM pg_catalog.pg_roles r
-               WHERE r.oid = ANY(p.polroles)) AS roles,
-         pg_get_expr(p.polqual, p.polrelid, true) AS using_expression,
-         pg_get_expr(p.polwithcheck, p.polrelid, true) AS check_expression
-  FROM pg_catalog.pg_policy p
-  JOIN pg_catalog.pg_class c ON c.oid = p.polrelid
-  JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-  WHERE n.nspname = $1
-  ORDER BY p.polrelid, p.oid
-`;
-/** Installed PostgreSQL extensions scoped to the selected schema. */
-const postgresExtensionsQuery = `
-  SELECT e.oid::text AS oid, n.nspname AS namespace,
-         e.extname AS physical_name, e.extversion, e.extrelocatable,
-         e.extconfig::text AS config_relations,
-         e.extcondition::text AS config_conditions
-  FROM pg_catalog.pg_extension e
-  JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace
-  WHERE n.nspname = $1
-  ORDER BY e.oid
-`;
-/** Comments and owners for PostgreSQL objects visible in one schema. */
-const postgresMetadataQuery = `
-  WITH objects AS (
-    SELECT 'pg_class'::text AS catalog_relation, 'pg_class'::regclass AS catalog_oid,
-           c.oid::text AS object_oid, 0::int AS object_subid,
-           CASE c.relkind WHEN 'r' THEN 'table' WHEN 'p' THEN 'table'
-             WHEN 'v' THEN 'view' WHEN 'm' THEN 'materialized-view'
-             WHEN 'S' THEN 'sequence' WHEN 'i' THEN 'index'
-             WHEN 'I' THEN 'index' WHEN 'f' THEN 'deferred-object'
-             ELSE 'opaque-object' END AS object_kind,
-           c.relname AS object_name, n.nspname AS namespace,
-           c.relowner::oid AS owner_oid, NULL::text AS parent_oid
-    FROM pg_catalog.pg_class c
-    JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-    WHERE n.nspname = $1
-    UNION ALL
-    SELECT 'pg_class', 'pg_class'::regclass, c.oid::text, a.attnum::int,
-           'column', a.attname, n.nspname, c.relowner::oid, c.oid::text
-    FROM pg_catalog.pg_attribute a
-    JOIN pg_catalog.pg_class c ON c.oid = a.attrelid
-    JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-    WHERE n.nspname = $1 AND c.relkind IN ('r', 'p', 'v', 'm')
-      AND a.attnum > 0 AND NOT a.attisdropped
-    UNION ALL
-    SELECT 'pg_proc', 'pg_proc'::regclass, p.oid::text, 0,
-           'routine', p.proname, n.nspname, p.proowner::oid, NULL
-    FROM pg_catalog.pg_proc p
-    JOIN pg_catalog.pg_namespace n ON n.oid = p.pronamespace
-    WHERE n.nspname = $1 AND p.prokind IN ('f', 'p', 'a', 'w')
-    UNION ALL
-    SELECT 'pg_type', 'pg_type'::regclass, t.oid::text, 0,
-           CASE t.typtype WHEN 'e' THEN 'enum' ELSE 'domain' END,
-           t.typname, n.nspname, t.typowner::oid, NULL
-    FROM pg_catalog.pg_type t
-    JOIN pg_catalog.pg_namespace n ON n.oid = t.typnamespace
-    WHERE n.nspname = $1 AND t.typtype IN ('e', 'd')
-    UNION ALL
-    SELECT 'pg_collation', 'pg_collation'::regclass, c.oid::text, 0,
-           'collation', c.collname, n.nspname, c.collowner::oid, NULL
-    FROM pg_catalog.pg_collation c
-    JOIN pg_catalog.pg_namespace n ON n.oid = c.collnamespace
-    WHERE n.nspname = $1
-    UNION ALL
-    SELECT 'pg_extension', 'pg_extension'::regclass, e.oid::text, 0,
-           'extension', e.extname, n.nspname, e.extowner::oid, NULL
-    FROM pg_catalog.pg_extension e
-    JOIN pg_catalog.pg_namespace n ON n.oid = e.extnamespace
-    WHERE n.nspname = $1
-    UNION ALL
-    SELECT 'pg_constraint', 'pg_constraint'::regclass, con.oid::text, 0,
-           'constraint', con.conname, n.nspname, c.relowner::oid,
-           con.conrelid::text
-    FROM pg_catalog.pg_constraint con
-    JOIN pg_catalog.pg_class c ON c.oid = con.conrelid
-    JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-    WHERE n.nspname = $1
-    UNION ALL
-    SELECT 'pg_trigger', 'pg_trigger'::regclass, t.oid::text, 0,
-           'trigger', t.tgname, n.nspname, c.relowner::oid,
-           t.tgrelid::text
-    FROM pg_catalog.pg_trigger t
-    JOIN pg_catalog.pg_class c ON c.oid = t.tgrelid
-    JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-    WHERE n.nspname = $1 AND NOT t.tgisinternal
-    UNION ALL
-    SELECT 'pg_policy', 'pg_policy'::regclass, p.oid::text, 0,
-           'policy', p.polname, n.nspname, c.relowner::oid,
-           p.polrelid::text
-    FROM pg_catalog.pg_policy p
-    JOIN pg_catalog.pg_class c ON c.oid = p.polrelid
-    JOIN pg_catalog.pg_namespace n ON n.oid = c.relnamespace
-    WHERE n.nspname = $1
-  )
-  SELECT o.catalog_relation, o.object_oid, o.object_subid,
-         o.object_kind, o.object_name, o.namespace, o.parent_oid,
-         d.description, pg_get_userbyid(o.owner_oid) AS owner
-  FROM objects o
-  LEFT JOIN pg_catalog.pg_description d
-    ON d.classoid = o.catalog_oid AND d.objoid::text = o.object_oid
-   AND d.objsubid = o.object_subid
-  ORDER BY o.catalog_relation, o.object_oid, o.object_subid
-`;
-async function query$1(connection, text, parameters, options, diagnostics, operation) {
-	try {
-		return await connection.query({
-			text,
-			parameters
-		}, { signal: options.signal });
-	} catch {
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "query-failed",
-			message: `PostgreSQL catalog query failed while reading ${operation}`,
-			path: [operation],
-			remediation: "Check PostgreSQL permissions and the selected schema."
-		}));
-		return [];
-	}
-}
-function serverInfo$1(row, diagnostics) {
-	const rawVersion = text$1(row?.server_version) ?? "unknown";
-	const numericVersion = number$1(row?.server_version_num);
-	if (!row) diagnostics.push(createIntrospectionDiagnostic({
-		severity: "error",
-		code: "unsupported-server",
-		message: "PostgreSQL server version metadata was unavailable",
-		path: ["server"],
-		remediation: "Provide access to current_setting(server_version_num)."
-	}));
-	const major = numericVersion ? Math.floor(numericVersion / 1e4) : void 0;
-	const supported = major !== void 0 && major >= 12;
-	if (!supported) diagnostics.push(createIntrospectionDiagnostic({
-		severity: "error",
-		code: "unsupported-server",
-		message: "PostgreSQL introspection requires server version 12 or newer",
-		path: ["server", "version"],
-		remediation: "Use PostgreSQL 12+ or an adapter capability extension."
-	}));
-	return {
-		product: "postgresql",
-		rawVersion,
-		parsedVersion: major === void 0 ? void 0 : { major },
-		capabilities: {
-			generatedColumns: supported,
-			identityMetadata: numericVersion !== void 0 && numericVersion >= 1e5,
-			checkConstraints: true,
-			checkConstraintEnforcement: "enforced",
-			expressionDecompilation: true,
-			indexExpressions: true,
-			indexPredicates: true,
-			indexIncludedColumns: true,
-			namespaces: true,
-			visibility: "complete"
-		}
-	};
-}
-function emptyCatalog$1(namespace, diagnostics) {
-	return {
-		dialect: "postgresql",
-		server: {
-			product: "postgresql",
-			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: "postgres-schema",
-			name: namespace
-		},
-		tables: [],
-		deferredObjects: [],
-		diagnostics: Object.freeze(diagnostics)
-	};
-}
-function viewObject(row, namespace, diagnostics) {
-	const physicalName = text$1(row.physical_name) ?? "unnamed_view";
-	const kind = row.relkind === "m" ? "materialized-view" : "view";
-	const physicalReference = reference$1(kind, physicalName, text$1(row.namespace) ?? namespace, "pg_class", "oid", row.oid);
-	const definition = text$1(row.definition);
-	if (definition === void 0) {
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "warning",
-			code: "unmodeled-object",
-			message: `PostgreSQL ${kind} ${physicalName} has no recoverable definition`,
-			path: [
-				"views",
-				physicalName,
-				"definition"
-			],
-			physicalReference,
-			remediation: "Grant access to pg_get_viewdef before treating this object as migration input."
-		}));
-		return deferredCatalogObject(kind === "view" ? "view" : "materialized-view", physicalName, physicalReference, [{
-			name: "definition",
-			value: expression("/* view definition unavailable */", "decompiler", physicalReference)
-		}]);
-	}
-	const options = stringArray(row.reloptions);
-	const checkOption = (() => {
-		const value = text$1(row.check_option)?.toLowerCase();
-		return value === "none" || value === "local" || value === "cascaded" ? value : void 0;
-	})();
-	return {
-		kind,
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		columns: [],
-		definition: expression(definition, "decompiler", physicalReference),
-		...checkOption === "local" || checkOption === "cascaded" ? { checkOption } : checkOption === "none" ? { checkOption: "none" } : {},
-		...booleanOption(options, "security_barrier") === void 0 ? {} : { securityBarrier: booleanOption(options, "security_barrier") },
-		...booleanOption(options, "security_invoker") === void 0 ? {} : { securityInvoker: booleanOption(options, "security_invoker") },
-		reference: physicalReference
-	};
-}
-function columnKey(tableOid, ordinalPosition) {
-	return `${text$1(tableOid) ?? "unknown"}:${number$1(ordinalPosition) ?? 0}`;
-}
-function compareOrdinal(left, right) {
-	return (number$1(left.ordinal_position) ?? 0) - (number$1(right.ordinal_position) ?? 0);
-}
-function identityOptions(row) {
-	const options = {};
-	for (const [key, value] of [
-		["start", row.seqstart],
-		["increment", row.seqincrement],
-		["minimum", row.seqmin],
-		["maximum", row.seqmax],
-		["cache", row.seqcache]
-	]) {
-		const fact = literalFact(value);
-		if (fact !== void 0) options[key] = fact;
-	}
-	if (row.seqcycle !== void 0) options.cycle = {
-		kind: "literal",
-		value: boolean$1(row.seqcycle)
-	};
-	if (text$1(row.sequence_type) !== void 0) options.type = {
-		kind: "literal",
-		value: text$1(row.sequence_type)
-	};
-	return options;
-}
-function sequenceObject(row, namespace, tableByOid, diagnostics) {
-	const physicalName = text$1(row.physical_name) ?? `sequence_${text$1(row.oid) ?? "unknown"}`;
-	const physicalReference = reference$1("sequence", physicalName, text$1(row.namespace) ?? namespace, "pg_class", "oid", row.oid);
-	const ownedTable = tableByOid.get(text$1(row.owned_table_oid));
-	const ownedBy = ownedTable ? {
-		kind: "table",
-		id: ownedTable.id
-	} : void 0;
-	const ownedTableOid = text$1(row.owned_table_oid);
-	const ownedColumnPosition = number$1(row.owned_column_position);
-	if (ownedTableOid !== void 0 && ownedBy === void 0) diagnostics.push(createIntrospectionDiagnostic({
-		severity: "warning",
-		code: "unresolved-reference",
-		message: `PostgreSQL sequence ${physicalName} has an ownership target outside the selected schema`,
-		path: [
-			"sequences",
-			physicalName,
-			"ownedBy"
-		],
-		physicalReference,
-		remediation: "Select the owning table schema or inspect the retained ownership catalog reference."
-	}));
-	const data = {};
-	if (ownedTableOid !== void 0) data.ownedTableOid = ownedTableOid;
-	if (ownedColumnPosition !== void 0) data.ownedColumnPosition = ownedColumnPosition;
-	return {
-		kind: "sequence",
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		storage: storage(row.native_type),
-		...factIfPresent(row.seqstart) === void 0 ? {} : { start: factIfPresent(row.seqstart) },
-		...factIfPresent(row.seqincrement) === void 0 ? {} : { increment: factIfPresent(row.seqincrement) },
-		...factIfPresent(row.seqmin) === void 0 ? {} : { minimum: factIfPresent(row.seqmin) },
-		...factIfPresent(row.seqmax) === void 0 ? {} : { maximum: factIfPresent(row.seqmax) },
-		...factIfPresent(row.seqcache) === void 0 ? {} : { cache: factIfPresent(row.seqcache) },
-		...row.seqcycle === void 0 || row.seqcycle === null ? {} : { cycle: boolean$1(row.seqcycle) },
-		...ownedBy === void 0 ? {} : { ownedBy },
-		...Object.keys(data).length === 0 ? {} : { dialect: {
-			dialect: "postgresql",
-			version: 1,
-			data
-		} },
-		reference: physicalReference
-	};
-}
-function mapEnums(rows, namespace) {
-	const groups = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const key = text$1(row.oid) ?? text$1(row.physical_name) ?? "unknown";
-		const values = groups.get(key) ?? [];
-		values.push(row);
-		groups.set(key, values);
-	}
-	return [...groups.values()].map((enumRows) => {
-		const first = enumRows[0];
-		const physicalName = text$1(first.physical_name) ?? `enum_${text$1(first.oid) ?? "unknown"}`;
-		const physicalReference = reference$1("enum", physicalName, text$1(first.namespace) ?? namespace, "pg_type", "oid", first.oid);
-		const values = [...enumRows].sort((left, right) => (number$1(left.ordinal_position) ?? 0) - (number$1(right.ordinal_position) ?? 0)).map((row, index) => ({
-			value: text$1(row.value) ?? "",
-			ordinalPosition: index + 1,
-			provenance: {
-				kind: "catalog",
-				dialect: "postgresql",
-				reference: reference$1("enum", physicalName, text$1(row.namespace) ?? namespace, "pg_enum", "oid", row.value_oid)
-			}
-		}));
-		return {
-			kind: "enum",
-			id: stableId$1(physicalName),
-			identitySource: "physical-name",
-			physicalName,
-			values,
-			reference: physicalReference
-		};
-	});
-}
-function mapDomains(rows, constraintRows, namespace) {
-	const constraintsByDomain = groupBy(constraintRows, (row) => text$1(row.domain_oid) ?? "unknown");
-	return rows.map((row) => {
-		const physicalName = text$1(row.physical_name) ?? `domain_${text$1(row.oid) ?? "unknown"}`;
-		const physicalReference = reference$1("domain", physicalName, text$1(row.namespace) ?? namespace, "pg_type", "oid", row.oid);
-		const domainConstraints = (constraintsByDomain.get(text$1(row.oid)) ?? []).map((constraintRow) => {
-			const constraintName = text$1(constraintRow.physical_name) ?? `domain_constraint_${text$1(constraintRow.oid) ?? "unknown"}`;
-			const constraintReference = reference$1("constraint", constraintName, text$1(row.namespace) ?? namespace, "pg_constraint", "oid", constraintRow.oid);
-			return {
-				kind: "check",
-				id: stableId$1(constraintName),
-				identitySource: "physical-name",
-				physicalName: constraintName,
-				expression: expression(text$1(constraintRow.definition) ?? "CHECK (true)", "decompiler", constraintReference),
-				deferrable: constraintRow.condeferrable === void 0 ? void 0 : boolean$1(constraintRow.condeferrable),
-				initially: constraintRow.condeferred === void 0 ? void 0 : boolean$1(constraintRow.condeferred) ? "deferred" : "immediate",
-				validated: constraintRow.convalidated === void 0 ? void 0 : boolean$1(constraintRow.convalidated),
-				reference: constraintReference
-			};
-		});
-		return {
-			kind: "domain",
-			id: stableId$1(physicalName),
-			identitySource: "physical-name",
-			physicalName,
-			storage: storage(row.native_type),
-			...row.nullable === void 0 || row.nullable === null ? {} : { nullable: boolean$1(row.nullable) },
-			...factIfPresent(row.default_expression) === void 0 ? {} : { default: factIfPresent(row.default_expression) },
-			...domainConstraints.length === 0 ? {} : { constraints: domainConstraints },
-			reference: physicalReference
-		};
-	});
-}
-function collationObject(row, namespace) {
-	const physicalName = text$1(row.physical_name) ?? `collation_${text$1(row.oid) ?? "unknown"}`;
-	return {
-		kind: "collation",
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		...text$1(row.collprovider) === void 0 ? {} : { provider: text$1(row.collprovider) },
-		...(text$1(row.colliculocale) ?? text$1(row.collcollate) ?? text$1(row.collctype)) === void 0 ? {} : { locale: text$1(row.colliculocale) ?? text$1(row.collcollate) ?? text$1(row.collctype) },
-		...row.collisdeterministic === void 0 || row.collisdeterministic === null ? {} : { deterministic: boolean$1(row.collisdeterministic) },
-		...text$1(row.collversion) === void 0 ? {} : { version: text$1(row.collversion) },
-		reference: reference$1("collation", physicalName, text$1(row.namespace) ?? namespace, "pg_collation", "oid", row.oid)
-	};
-}
-function triggerObject(row, namespace, relationReferences, diagnostics) {
-	const physicalName = text$1(row.physical_name) ?? `trigger_${text$1(row.oid) ?? "unknown"}`;
-	const physicalReference = reference$1("trigger", physicalName, text$1(row.namespace) ?? namespace, "pg_trigger", "oid", row.oid);
-	const table = relationReferences.get(text$1(row.table_oid));
-	const definition = text$1(row.definition);
-	if (table === void 0 || definition === void 0) {
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "warning",
-			code: table === void 0 ? "unresolved-reference" : "unmodeled-object",
-			message: table === void 0 ? `PostgreSQL trigger ${physicalName} has no selected parent relation` : `PostgreSQL trigger ${physicalName} has no recoverable definition`,
-			path: ["triggers", physicalName],
-			physicalReference,
-			remediation: "Retain the deferred trigger until its parent relation and definition are visible."
-		}));
-		return deferredCatalogObject("trigger", physicalName, physicalReference, [...table === void 0 ? [{
-			name: "tableOid",
-			value: text$1(row.table_oid) ?? "unknown"
-		}] : [], ...definition === void 0 ? [] : [{
-			name: "definition",
-			value: expression(definition, "decompiler", physicalReference)
-		}]]);
-	}
-	const triggerType = number$1(row.trigger_type) ?? 0;
-	const timing = triggerType & 64 ? "instead-of" : triggerType & 2 ? "before" : "after";
-	const events = triggerEvents$1(triggerType);
-	const mode = triggerType & 1 ? "row" : "statement";
-	const enabled = triggerEnabled(row.tgenabled);
-	return {
-		kind: "trigger",
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		table,
-		timing,
-		events,
-		orientation: mode,
-		...text$1(row.condition) === void 0 ? {} : { condition: expression(text$1(row.condition), "decompiler", physicalReference) },
-		body: expression(definition, "decompiler", physicalReference),
-		...enabled === void 0 ? {} : { enabled },
-		reference: physicalReference
-	};
-}
-function mapRoutines(rows, parameterRows, namespace, diagnostics) {
-	const parametersByRoutine = groupBy(parameterRows, (row) => text$1(row.routine_oid) ?? "unknown");
-	const names = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const name = text$1(row.physical_name) ?? `routine_${text$1(row.oid) ?? "unknown"}`;
-		names.set(name, (names.get(name) ?? 0) + 1);
-	}
-	return rows.map((row) => {
-		const physicalName = text$1(row.physical_name) ?? `routine_${text$1(row.oid) ?? "unknown"}`;
-		const physicalReference = reference$1("routine", physicalName, text$1(row.namespace) ?? namespace, "pg_proc", "oid", row.oid);
-		const identityArguments = text$1(row.identity_arguments);
-		const defaultArguments = text$1(row.argument_defaults);
-		if (defaultArguments !== void 0) diagnostics.push(createIntrospectionDiagnostic({
-			severity: "info",
-			code: "unmodeled-object",
-			message: `PostgreSQL routine ${physicalName} retains its argument defaults as opaque catalog text`,
-			path: [
-				"routines",
-				physicalName,
-				"argumentDefaults"
-			],
-			physicalReference,
-			remediation: "Review routine argument defaults before using the complete snapshot for migration planning."
-		}));
-		if (text$1(row.definition) === void 0) diagnostics.push(createIntrospectionDiagnostic({
-			severity: "warning",
-			code: "unmodeled-object",
-			message: `PostgreSQL routine ${physicalName} has no recoverable definition`,
-			path: [
-				"routines",
-				physicalName,
-				"definition"
-			],
-			physicalReference,
-			remediation: "Grant access to pg_get_functiondef before treating this routine as migration input."
-		}));
-		const routineUnknownFields = [...identityArguments === void 0 ? [] : [{
-			name: "identityArguments",
-			value: expression(identityArguments, "decompiler", physicalReference)
-		}], ...defaultArguments === void 0 ? [] : [{
-			name: "argumentDefaults",
-			value: expression(defaultArguments, "decompiler", physicalReference)
-		}]];
-		const parameters = (parametersByRoutine.get(text$1(row.oid)) ?? []).sort((left, right) => (number$1(left.ordinal_position) ?? 0) - (number$1(right.ordinal_position) ?? 0)).map((parameter) => ({
-			...text$1(parameter.parameter_name) === void 0 ? {} : { name: text$1(parameter.parameter_name) },
-			...routineParameterMode(parameter.mode) === void 0 ? {} : { mode: routineParameterMode(parameter.mode) },
-			storage: storage(parameter.native_type),
-			ordinalPosition: number$1(parameter.ordinal_position) ?? 0,
-			provenance: {
-				kind: "catalog",
-				dialect: "postgresql",
-				reference: physicalReference
-			}
-		}));
-		return {
-			kind: "routine",
-			id: stableId$1((names.get(physicalName) ?? 0) < 2 || identityArguments === void 0 ? physicalName : `${physicalName}_${identityArguments.replace(/[^a-zA-Z0-9_]+/g, "_")}`),
-			identitySource: "physical-name",
-			physicalName,
-			routineKind: routineKind(row.prokind),
-			parameters,
-			...text$1(row.return_type) === void 0 ? {} : { returnType: storage(row.return_type) },
-			...text$1(row.language) === void 0 ? {} : { language: text$1(row.language) },
-			...text$1(row.definition) === void 0 ? {} : { body: expression(text$1(row.definition), "decompiler", physicalReference) },
-			...routineVolatility(row.provolatile) === void 0 ? {} : { volatility: routineVolatility(row.provolatile) },
-			...routineParallel(row.proparallel) === void 0 ? {} : { parallel: routineParallel(row.proparallel) },
-			...row.prosecdef === void 0 || row.prosecdef === null ? {} : { security: boolean$1(row.prosecdef) ? "definer" : "invoker" },
-			...routineUnknownFields.length === 0 ? {} : { unknownFields: routineUnknownFields },
-			reference: physicalReference
-		};
-	});
-}
-function partitionObject(row, namespace, tableByOid, diagnostics) {
-	const physicalName = text$1(row.physical_name) ?? `partition_${text$1(row.partition_oid) ?? "unknown"}`;
-	const physicalReference = reference$1("partition", physicalName, text$1(row.namespace) ?? namespace, "pg_class", "oid", row.partition_oid);
-	const parent = tableByOid.get(text$1(row.parent_oid));
-	if (parent === void 0) diagnostics.push(createIntrospectionDiagnostic({
-		severity: "error",
-		code: "unresolved-reference",
-		message: `PostgreSQL partition ${physicalName} has no parent table in the selected schema`,
-		path: [
-			"partitions",
-			physicalName,
-			"parent"
-		],
-		physicalReference,
-		remediation: "Select the parent table schema before mapping partitions."
-	}));
-	const parentReference = parent ? {
-		kind: "table",
-		id: parent.id
-	} : {
-		kind: "table",
-		id: stableId$1(`missing_parent_${text$1(row.parent_oid) ?? "unknown"}`)
-	};
-	const keyColumns = partitionKeyColumns(row.key_attributes, parent?.columns ?? []);
-	const bound = text$1(row.bound);
-	return {
-		kind: "partition",
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		parent: parentReference,
-		strategy: partitionStrategy(row.partstrat),
-		...keyColumns.length === 0 ? {} : { keyColumns },
-		...bound === void 0 ? {} : { bound: expression(bound, "decompiler", physicalReference) },
-		...bound !== void 0 && /^default$/i.test(bound.trim()) ? { default: true } : {},
-		reference: physicalReference
-	};
-}
-function policyObject(row, namespace, tableByOid, diagnostics) {
-	const physicalName = text$1(row.physical_name) ?? `policy_${text$1(row.oid) ?? "unknown"}`;
-	const physicalReference = reference$1("policy", physicalName, text$1(row.namespace) ?? namespace, "pg_policy", "oid", row.oid);
-	const table = tableByOid.get(text$1(row.table_oid));
-	if (table === void 0) diagnostics.push(createIntrospectionDiagnostic({
-		severity: "error",
-		code: "unresolved-reference",
-		message: `PostgreSQL policy ${physicalName} has no selected table`,
-		path: [
-			"policies",
-			physicalName,
-			"table"
-		],
-		physicalReference,
-		remediation: "Select the policy table schema before mapping row-level security."
-	}));
-	return {
-		kind: "policy",
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		table: table ? {
-			kind: "table",
-			id: table.id
-		} : {
-			kind: "table",
-			id: stableId$1(`missing_table_${text$1(row.table_oid) ?? "unknown"}`)
-		},
-		command: policyCommand(row.polcmd),
-		...stringArray(row.roles).length === 0 ? {} : { roles: stringArray(row.roles) },
-		...row.polpermissive === void 0 || row.polpermissive === null ? {} : { permissive: boolean$1(row.polpermissive) },
-		...text$1(row.using_expression) === void 0 ? {} : { using: expression(text$1(row.using_expression), "decompiler", physicalReference) },
-		...text$1(row.check_expression) === void 0 ? {} : { check: expression(text$1(row.check_expression), "decompiler", physicalReference) },
-		reference: physicalReference
-	};
-}
-function extensionObject(row, namespace) {
-	const physicalName = text$1(row.physical_name) ?? `extension_${text$1(row.oid) ?? "unknown"}`;
-	const physicalReference = reference$1("extension", physicalName, text$1(row.namespace) ?? namespace, "pg_extension", "oid", row.oid);
-	const data = { relocatable: boolean$1(row.extrelocatable) };
-	const configuration = {};
-	if (text$1(row.config_relations) !== void 0) configuration.relations = text$1(row.config_relations);
-	if (text$1(row.config_conditions) !== void 0) configuration.conditions = text$1(row.config_conditions);
-	return {
-		kind: "extension",
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		extensionName: physicalName,
-		...text$1(row.extversion) === void 0 ? {} : { extensionVersion: text$1(row.extversion) },
-		...text$1(row.namespace) === void 0 ? {} : { schema: text$1(row.namespace) },
-		data,
-		...Object.keys(configuration).length === 0 ? {} : { configuration },
-		dialect: {
-			dialect: "postgresql",
-			version: 1,
-			data: { relocatable: boolean$1(row.extrelocatable) }
-		},
-		reference: physicalReference
-	};
-}
-function deferredCatalogObject(objectKind, physicalName, physicalReference, unknownFields = []) {
-	return {
-		kind: "deferred-object",
-		objectKind,
-		id: stableId$1(`deferred_${objectKind}_${physicalName}`),
-		identitySource: "physical-name",
-		physicalName,
-		reference: physicalReference,
-		...unknownFields.length === 0 ? {} : { unknownFields }
-	};
-}
-function triggerEvents$1(triggerType) {
-	const events = [];
-	if (triggerType & 4) events.push("insert");
-	if (triggerType & 8) events.push("delete");
-	if (triggerType & 16) events.push("update");
-	if (triggerType & 32) events.push("truncate");
-	return events.sort();
-}
-function triggerEnabled(value) {
-	const code = text$1(value)?.toUpperCase();
-	if (code === "D") return false;
-	if (code === "O" || code === "R" || code === "A") return true;
-}
-function routineKind(value) {
-	return {
-		f: "function",
-		p: "procedure",
-		a: "aggregate",
-		w: "window"
-	}[text$1(value)] ?? "unknown";
-}
-function routineParameterMode(value) {
-	return {
-		i: "in",
-		o: "out",
-		b: "inout",
-		v: "variadic",
-		t: "table"
-	}[text$1(value)];
-}
-function routineVolatility(value) {
-	return {
-		i: "immutable",
-		s: "stable",
-		v: "volatile"
-	}[text$1(value)];
-}
-function routineParallel(value) {
-	return {
-		s: "safe",
-		r: "restricted",
-		u: "unsafe"
-	}[text$1(value)];
-}
-function partitionStrategy(value) {
-	return {
-		r: "range",
-		l: "list",
-		h: "hash"
-	}[text$1(value)] ?? "unknown";
-}
-function partitionKeyColumns(value, columns) {
-	const byOrdinal = new Map(columns.map((column) => [column.ordinalPosition, column.physicalName]));
-	return integerArray(value).filter((position) => position > 0).map((position) => byOrdinal.get(position) ?? `attnum_${position}`);
-}
-function policyCommand(value) {
-	return {
-		"*": "all",
-		r: "select",
-		a: "insert",
-		w: "update",
-		d: "delete"
-	}[text$1(value)] ?? "unknown";
-}
-function storage(value) {
-	return { nativeType: text$1(value) ?? "unknown" };
-}
-function factIfPresent(value) {
-	if (value === void 0 || value === null) return;
-	return literalFact(value);
-}
-function literalFact(value) {
-	if (value === void 0) return;
-	if (value === null) return {
-		kind: "literal",
-		value: null
-	};
-	if (typeof value === "boolean") return {
-		kind: "literal",
-		value
-	};
-	if (typeof value === "bigint") return {
-		kind: "literal",
-		value
-	};
-	if (typeof value === "number") return Number.isFinite(value) ? {
-		kind: "literal",
-		value
-	} : {
-		kind: "literal",
-		value: String(value)
-	};
-	const textValue = String(value);
-	if (/^[+-]?\d+$/.test(textValue.trim())) try {
-		const integerValue = BigInt(textValue);
-		if (integerValue > BigInt(Number.MAX_SAFE_INTEGER) || integerValue < BigInt(Number.MIN_SAFE_INTEGER)) return {
-			kind: "literal",
-			value: integerValue
-		};
-	} catch {}
-	const numericValue = Number(textValue);
-	return textValue.trim() !== "" && Number.isFinite(numericValue) ? {
-		kind: "literal",
-		value: numericValue
-	} : {
-		kind: "literal",
-		value: textValue
-	};
-}
-function relationTable(row) {
-	const physicalName = text$1(row.relname) ?? "unnamed_table";
-	return {
-		kind: "table",
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		reference: reference$1("table", physicalName, text$1(row.namespace), "pg_class", "oid", row.oid),
-		columns: [],
-		constraints: [],
-		indexes: [],
-		unknownFields: boolean$1(row.relispartition) ? [{
-			name: "partitioned",
-			value: true
-		}] : void 0
-	};
-}
-function deferredObject(row, objectKind = "other") {
-	const physicalName = text$1(row.relname) ?? "unnamed_object";
-	return {
-		kind: "deferred-object",
-		objectKind,
-		id: stableId$1(`deferred:${objectKind}:${physicalName}`),
-		identitySource: "physical-name",
-		physicalName,
-		reference: reference$1("deferred-object", physicalName, text$1(row.namespace), "pg_class", "oid", row.oid)
-	};
-}
-function opaqueRelationObject(row, namespace, diagnostics) {
-	const physicalName = text$1(row.relname) ?? "unnamed_object";
-	const relkind = text$1(row.relkind) ?? "unknown";
-	const physicalReference = reference$1("opaque-object", physicalName, text$1(row.namespace) ?? namespace, "pg_class", "oid", row.oid);
-	diagnostics.push(createIntrospectionDiagnostic({
-		severity: "warning",
-		code: "unmodeled-object",
-		message: `PostgreSQL relation ${physicalName} (${relkind}) was retained as an opaque object`,
-		path: ["opaqueObjects", physicalName],
-		physicalReference,
-		remediation: "Inspect the opaque object before treating it as migration input."
-	}));
-	return {
-		kind: "opaque-object",
-		id: stableId$1(`relation:${relkind}:${physicalName}`),
-		identitySource: "physical-name",
-		physicalName,
-		objectKind: `postgres-relation:${relkind}`,
-		data: {
-			relkind,
-			relispartition: boolean$1(row.relispartition)
-		},
-		reference: physicalReference
-	};
-}
-function column$1(row, table, namespace, identityOptionValues) {
-	const physicalName = text$1(row.physical_name) ?? "unnamed_column";
-	const defaultExpression = text$1(row.default_expression);
-	const identityValue = text$1(row.attidentity);
-	const generatedValue = text$1(row.attgenerated);
-	const identity = identityValue === "a" || identityValue === "d" ? {
-		kind: "identity",
-		generation: identityValue === "a" ? "always" : "by-default",
-		options: identityOptionValues ?? {}
-	} : void 0;
-	const generated = (generatedValue === "s" || generatedValue === "v") && defaultExpression ? {
-		kind: "generated",
-		mode: generatedValue === "s" ? "stored" : "virtual",
-		expression: sql$1(defaultExpression, namespace, table, physicalName)
-	} : void 0;
-	const ordinaryDefault = defaultExpression && !identity && !generated ? {
-		kind: "expression",
-		expression: sql$1(defaultExpression, namespace, table, physicalName)
-	} : void 0;
-	return {
-		kind: "column",
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		ordinalPosition: number$1(row.ordinal_position) ?? 0,
-		nullable: boolean$1(row.nullable),
-		storage: { nativeType: text$1(row.native_type) ?? "unknown" },
-		...ordinaryDefault ? { default: ordinaryDefault } : {},
-		...generated ? { generated } : {},
-		identity,
-		reference: reference$1("column", physicalName, namespace, "pg_attribute", "attrelid", row.table_oid)
-	};
-}
-function constraint(row, table, columnsByNumber, tableByOid, namespace, diagnostics, indexReferences) {
-	const kind = text$1(row.contype);
-	const physicalName = text$1(row.physical_name) ?? `constraint_${text$1(row.oid) ?? "unknown"}`;
-	const columns = integerArray(row.conkey).map((numberValue) => columnsByNumber.get(numberValue) ?? `attnum_${numberValue}`);
-	const common = {
-		id: stableId$1(physicalName),
-		identitySource: "physical-name",
-		physicalName,
-		deferrable: boolean$1(row.condeferrable),
-		initially: boolean$1(row.condeferred) ? "deferred" : "immediate",
-		validated: boolean$1(row.convalidated),
-		reference: reference$1("constraint", physicalName, namespace, "pg_constraint", "oid", row.oid),
-		dialect: row.convalidated === false ? {
-			dialect: "postgresql",
-			version: 1,
-			data: { notValid: true }
-		} : void 0
-	};
-	const backingOid = text$1(row.backing_index_oid);
-	const backing = backingOid ? indexReferences.get(`pg_class:${backingOid}`) : void 0;
-	const backingIndex = backing ? {
-		kind: "index",
-		id: backing.id
-	} : void 0;
-	if (kind === "p") return {
-		kind: "primary-key",
-		...common,
-		columns,
-		...backingIndex === void 0 ? {} : { backingIndex }
-	};
-	if (kind === "u") return {
-		kind: "unique",
-		...common,
-		columns,
-		nulls: boolean$1(row.indnullsnotdistinct) ? "not-distinct" : "distinct",
-		...backingIndex === void 0 ? {} : { backingIndex }
-	};
-	if (kind === "c") return {
-		kind: "check",
-		...common,
-		expression: sql$1(text$1(row.definition) ?? "CHECK (true)", namespace, table, physicalName)
-	};
-	if (kind !== "f") return;
-	const targetTable = tableByOid.get(text$1(row.target_table_oid));
-	if (!targetTable) {
-		diagnostics.push(createIntrospectionDiagnostic({
-			severity: "error",
-			code: "unresolved-reference",
-			message: `PostgreSQL foreign key target ${text$1(row.target_table_oid) ?? "unknown"} was not found`,
-			path: [
-				"tables",
-				table.id,
-				"constraints",
-				physicalName
-			]
-		}));
-		return;
-	}
-	const targetColumns = integerArray(row.confkey).map((numberValue) => {
-		return targetTable.columns.find((column) => column.ordinalPosition === numberValue)?.physicalName ?? `attnum_${numberValue}`;
-	});
-	return {
-		kind: "foreign-key",
-		...common,
-		columns,
-		target: {
-			table: targetTable.physicalName,
-			columns: targetColumns
-		},
-		onUpdate: referentialAction(row.confupdtype),
-		onDelete: referentialAction(row.confdeltype),
-		match: matchType(row.confmatchtype)
-	};
-}
-function mapIndexes(rows, table, columnsByNumber, namespace) {
-	const grouped = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const key = text$1(row.index_oid) ?? text$1(row.physical_name) ?? "unknown";
-		const existing = grouped.get(key) ?? [];
-		existing.push(row);
-		grouped.set(key, existing);
-	}
-	return [...grouped.values()].map((indexRows) => {
-		const orderedRows = [...indexRows].sort((left, right) => (number$1(left.position) ?? 0) - (number$1(right.position) ?? 0));
-		const first = orderedRows[0];
-		const physicalName = text$1(first.physical_name) ?? `index_${text$1(first.index_oid) ?? "unknown"}`;
-		const keyCount = number$1(first.indnkeyatts) ?? indexRows.length;
-		const terms = [];
-		const includedColumns = [];
-		for (const row of orderedRows) {
-			const position = number$1(row.position) ?? 0;
-			const attnum = number$1(row.attnum) ?? 0;
-			const columnName = attnum > 0 ? columnsByNumber.get(attnum) : void 0;
-			if (position > keyCount) {
-				if (columnName) includedColumns.push(columnName);
-				continue;
-			}
-			terms.push(columnName ? {
-				kind: "column",
-				column: columnName,
-				position,
-				...indexTermOptions(row, text$1(first.method)),
-				...text$1(row.operator_class) === void 0 ? {} : { operatorClass: text$1(row.operator_class) }
-			} : {
-				kind: "expression",
-				expression: sql$1(text$1(row.term_definition) ?? "/* expression unavailable */", namespace, table, physicalName),
-				position,
-				...indexTermOptions(row, text$1(first.method)),
-				...text$1(row.operator_class) === void 0 ? {} : { operatorClass: text$1(row.operator_class) }
-			});
-		}
-		return {
-			kind: "index",
-			id: stableId$1(physicalName),
-			identitySource: "physical-name",
-			physicalName,
-			unique: boolean$1(first.indisunique),
-			terms,
-			predicate: text$1(first.predicate) ? sql$1(text$1(first.predicate), namespace, table, physicalName) : void 0,
-			includedColumns: includedColumns.length > 0 ? includedColumns : void 0,
-			method: text$1(first.method),
-			dialect: text$1(first.method) && text$1(first.method) !== "btree" ? {
-				dialect: "postgresql",
-				version: 1,
-				data: { method: text$1(first.method) }
-			} : void 0,
-			reference: reference$1("index", physicalName, namespace, "pg_class", "oid", first.index_oid)
-		};
-	});
-}
-function mapMetadataRows(rows, namespace, tables, views, sequences, enums, domains, collations, routines, triggers, policies, extensions, deferredObjects, opaqueObjects, indexReferences, relationReferences, diagnostics) {
-	const targets = /* @__PURE__ */ new Map();
-	const add = (relation, oid, object, physicalName, objectReference) => {
-		const ref = objectReference ?? reference$1(object.kind, physicalName, namespace, relation, "oid", oid);
-		targets.set(metadataKey(relation, oid, 0), {
-			object,
-			reference: ref,
-			physicalName
-		});
-	};
-	for (const table of tables) if (table.reference?.catalog !== void 0) add("pg_class", table.reference.catalog.value, {
-		kind: "table",
-		id: table.id
-	}, table.physicalName, table.reference);
-	for (const view of views) if (view.reference?.catalog !== void 0) add("pg_class", view.reference.catalog.value, {
-		kind: view.kind,
-		id: view.id
-	}, view.physicalName, view.reference);
-	for (const sequence of sequences) if (sequence.reference?.catalog !== void 0) add("pg_class", sequence.reference.catalog.value, {
-		kind: "sequence",
-		id: sequence.id
-	}, sequence.physicalName, sequence.reference);
-	for (const deferred of deferredObjects) if (deferred.reference?.catalog !== void 0 && deferred.id !== void 0) add("pg_class", deferred.reference.catalog.value, {
-		kind: "deferred-object",
-		id: deferred.id
-	}, deferred.physicalName, deferred.reference);
-	for (const opaque of opaqueObjects) if (opaque.reference?.catalog !== void 0) add("pg_class", opaque.reference.catalog.value, {
-		kind: "opaque-object",
-		id: opaque.id
-	}, opaque.physicalName, opaque.reference);
-	for (const index of indexReferences.values()) if (index.reference?.catalog !== void 0) add("pg_class", index.reference.catalog.value, {
-		kind: "index",
-		id: index.id
-	}, index.physicalName, index.reference);
-	for (const enumObject of enums) if (enumObject.reference?.catalog !== void 0) add("pg_type", enumObject.reference.catalog.value, {
-		kind: "enum",
-		id: enumObject.id
-	}, enumObject.physicalName, enumObject.reference);
-	for (const domain of domains) if (domain.reference?.catalog !== void 0) add("pg_type", domain.reference.catalog.value, {
-		kind: "domain",
-		id: domain.id
-	}, domain.physicalName, domain.reference);
-	for (const collation of collations) if (collation.reference?.catalog !== void 0) add("pg_collation", collation.reference.catalog.value, {
-		kind: "collation",
-		id: collation.id
-	}, collation.physicalName, collation.reference);
-	for (const routine of routines) if (routine.reference?.catalog !== void 0) add("pg_proc", routine.reference.catalog.value, {
-		kind: "routine",
-		id: routine.id
-	}, routine.physicalName, routine.reference);
-	for (const trigger of triggers) if (trigger.reference?.catalog !== void 0) add("pg_trigger", trigger.reference.catalog.value, {
-		kind: "trigger",
-		id: trigger.id
-	}, trigger.physicalName, trigger.reference);
-	for (const policy of policies) if (policy.reference?.catalog !== void 0) add("pg_policy", policy.reference.catalog.value, {
-		kind: "policy",
-		id: policy.id
-	}, policy.physicalName, policy.reference);
-	for (const extension of extensions) if (extension.reference?.catalog !== void 0) add("pg_extension", extension.reference.catalog.value, {
-		kind: "extension",
-		id: extension.id
-	}, extension.physicalName, extension.reference);
-	for (const table of tables) addNestedColumns(targets, "pg_class", table, namespace);
-	for (const view of views) addNestedColumns(targets, "pg_class", view, namespace);
-	for (const table of tables) for (const constraint of table.constraints) if (constraint.reference?.catalog !== void 0) targets.set(metadataKey("pg_constraint", constraint.reference.catalog.value, 0), {
-		object: {
-			kind: "constraint",
-			id: constraint.id
-		},
-		reference: constraint.reference,
-		physicalName: constraint.physicalName ?? constraint.id
-	});
-	for (const domain of domains) for (const constraint of domain.constraints ?? []) if (constraint.reference?.catalog !== void 0) targets.set(metadataKey("pg_constraint", constraint.reference.catalog.value, 0), {
-		object: {
-			kind: "constraint",
-			id: constraint.id
-		},
-		reference: constraint.reference,
-		physicalName: constraint.physicalName ?? constraint.id
-	});
-	const comments = [];
-	const ownership = [];
-	const opaque = [];
-	for (const [index, row] of rows.entries()) {
-		const relation = text$1(row.catalog_relation) ?? "unknown";
-		const oid = text$1(row.object_oid);
-		const subid = number$1(row.object_subid) ?? 0;
-		const target = targets.get(metadataKey(relation, oid, subid));
-		if (target === void 0) {
-			const unknownReference = reference$1("opaque-object", text$1(row.object_name) ?? `metadata_${oid ?? "unknown"}`, text$1(row.namespace) ?? namespace, relation, "oid", oid);
-			diagnostics.push(createIntrospectionDiagnostic({
-				severity: "warning",
-				code: "unmodeled-object",
-				message: `PostgreSQL metadata row for ${text$1(row.object_name) ?? "unknown object"} could not be attached to a normalized object`,
-				path: ["metadata", index],
-				physicalReference: unknownReference,
-				remediation: "Inspect the retained opaque metadata record before using it as migration input."
-			}));
-			opaque.push({
-				kind: "opaque-object",
-				id: stableId$1(`metadata_${relation}_${oid ?? "unknown"}_${subid}`),
-				identitySource: "physical-name",
-				physicalName: text$1(row.object_name) ?? `metadata_${oid ?? "unknown"}`,
-				objectKind: `postgres-metadata:${text$1(row.object_kind) ?? "unknown"}`,
-				data: {
-					catalogRelation: relation,
-					objectOid: oid ?? "unknown",
-					objectSubid: subid,
-					...text$1(row.description) === void 0 ? {} : { description: text$1(row.description) },
-					...text$1(row.owner) === void 0 ? {} : { owner: text$1(row.owner) }
-				},
-				reference: unknownReference
-			});
-			continue;
-		}
-		const description = text$1(row.description);
-		if (description !== void 0) comments.push({
-			kind: "comment",
-			id: stableId$1(`${target.object.kind}_${target.object.id}_comment`),
-			object: target.object,
-			text: description,
-			reference: target.reference,
-			provenance: {
-				kind: "catalog",
-				dialect: "postgresql",
-				reference: target.reference
-			}
-		});
-		const owner = text$1(row.owner);
-		if (owner !== void 0) ownership.push({
-			kind: "ownership",
-			id: stableId$1(`${target.object.kind}_${target.object.id}_ownership`),
-			object: target.object,
-			owner,
-			reference: target.reference,
-			provenance: {
-				kind: "catalog",
-				dialect: "postgresql",
-				reference: target.reference
-			}
-		});
-	}
-	return {
-		comments,
-		ownership,
-		opaqueObjects: opaque
-	};
-}
-function addNestedColumns(targets, relation, owner, namespace) {
-	const tableOid = owner.reference?.catalog?.value;
-	if (tableOid === void 0) return;
-	for (const column of owner.columns) targets.set(metadataKey(relation, tableOid, column.ordinalPosition), {
-		object: {
-			kind: "column",
-			id: column.id
-		},
-		reference: column.reference ?? reference$1("column", column.physicalName, namespace, "pg_attribute", "attrelid", tableOid),
-		physicalName: column.physicalName
-	});
-}
-function metadataKey(relation, oid, subid) {
-	return `${relation}:${text$1(oid) ?? "unknown"}:${number$1(subid) ?? 0}`;
-}
-function indexTermOptions(row, method) {
-	const option = number$1(row.indoption);
-	if (method !== "btree" || option === void 0) return {};
-	return {
-		direction: option & 1 ? "DESC" : "ASC",
-		nulls: option & 2 ? "FIRST" : "LAST"
-	};
-}
-function sql$1(textValue, namespace, owner, name) {
-	return expression(textValue, "decompiler", owner.reference ?? reference$1("table", name, namespace, "pg_class", "relname", owner.physicalName));
-}
-function expression(textValue, provenanceKind, physicalReference) {
-	return {
-		kind: "sql",
-		dialect: "postgresql",
-		text: textValue,
-		provenance: {
-			kind: provenanceKind,
-			dialect: "postgresql",
-			...physicalReference === void 0 ? {} : { reference: physicalReference }
-		}
-	};
-}
-function reference$1(kind, name, namespace, relation, key, value = name) {
-	return {
-		kind,
-		name,
-		namespace,
-		catalog: {
-			relation,
-			key,
-			value: typeof value === "number" ? value : String(value)
-		}
-	};
-}
-function stableId$1(value) {
-	if (value.length > 0 && !/[.\\\u0000-\u001f\u007f]/.test(value)) return value;
-	let hash = 2166136261;
-	for (let index = 0; index < value.length; index += 1) {
-		hash ^= value.charCodeAt(index);
-		hash = Math.imul(hash, 16777619);
-	}
-	return `introspected_${(hash >>> 0).toString(16)}`;
-}
-function groupBy(rows, key) {
-	const result = /* @__PURE__ */ new Map();
-	for (const row of rows) {
-		const value = key(row);
-		const group = result.get(value) ?? [];
-		group.push(row);
-		result.set(value, group);
-	}
-	return result;
-}
-function text$1(value) {
-	return value === null || value === void 0 ? void 0 : String(value);
-}
-function number$1(value) {
-	if (typeof value === "number" && Number.isFinite(value)) return value;
-	if (typeof value === "string" && value.trim() !== "") {
-		const parsed = Number(value);
-		return Number.isFinite(parsed) ? parsed : void 0;
-	}
-}
-function boolean$1(value) {
-	return value === true || value === "t" || value === "true" || value === 1;
-}
-function stringArray(value) {
-	if (Array.isArray(value)) return value.map((item) => text$1(item)).filter((item) => item !== void 0);
-	const source = text$1(value)?.trim();
-	if (source === void 0 || source === "") return [];
-	if (source.startsWith("{") && source.endsWith("}")) {
-		const values = [];
-		let current = "";
-		let quoted = false;
-		let escaped = false;
-		for (const character of source.slice(1, -1)) if (escaped) {
-			current += character;
-			escaped = false;
-		} else if (character === "\\" && quoted) escaped = true;
-		else if (character === "\"") quoted = !quoted;
-		else if (character === "," && !quoted) {
-			values.push(current);
-			current = "";
-		} else current += character;
-		if (current !== "" || source !== "{}") values.push(current);
-		return values.filter((value) => value !== "");
-	}
-	return source.split(",").map((item) => item.trim()).filter((item) => item !== "");
-}
-function booleanOption(options, name) {
-	const value = options.find((option) => option.startsWith(`${name}=`));
-	if (value === void 0) return;
-	const setting = value.slice(name.length + 1).toLowerCase();
-	if (setting === "true" || setting === "on" || setting === "yes") return true;
-	if (setting === "false" || setting === "off" || setting === "no") return false;
-}
-function integerArray(value) {
-	if (Array.isArray(value)) return value.map((item) => number$1(item) ?? 0);
-	const parsed = text$1(value)?.replace(/[{}]/g, "").trim();
-	if (!parsed) return [];
-	return parsed.split(",").map((item) => number$1(item.trim()) ?? 0);
-}
-function referentialAction(value) {
-	return {
-		a: "no-action",
-		r: "restrict",
-		c: "cascade",
-		n: "set-null",
-		d: "set-default"
-	}[text$1(value)];
-}
-function matchType(value) {
-	return {
-		s: "simple",
-		f: "full",
-		p: "partial"
-	}[text$1(value)];
-}
-//#endregion
-//#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 readSqliteCatalog(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 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 = sqliteView(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);
-		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 = sqliteIndex(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}`);
-		mappedConstraints.push(...foreignKeys(currentTable, foreignRows, options.namespace));
-		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 = sqliteTrigger(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: sqliteExtension({
-				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 sqliteView(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: sqliteExtension({ 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: sqliteExtension({ 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: sqliteExtension({ objectKind: type })
-	};
-}
-function sqliteTrigger(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: sqliteExtension({
-			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 sqliteAffinity(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 sqliteExtension(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: sqliteExtension({ 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: sqliteExtension({
-			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: sqliteExtension({ 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,
-		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: sqliteExtension({
-			declaredType: type,
-			affinity: sqliteAffinity(type),
-			hidden
-		})
-	};
-}
-function tableConstraints(table, rows, columns, sqlText, namespace) {
-	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: sqliteExtension({ source: "pragma_table_xinfo" }),
-			reference: reference("constraint", primaryName, namespace, "sqlite_schema", "tbl_name")
-		};
-		constraints.push(primary);
-	}
-	[...sqlText?.matchAll(/(?:CONSTRAINT\s+("(?:[^"]|"")*"|`[^`]*`|\[[^\]]*\]|[A-Za-z_][A-Za-z0-9_$]*)\s+)?CHECK\s*\(([^()]*(?:\([^()]*\)[^()]*)*)\)/gi) ?? []].forEach((match, index) => {
-		const name = unquoteIdentifier(match[1]) ?? `check_${index}_${table.physicalName}`;
-		const check = {
-			kind: "check",
-			id: stableId(name),
-			identitySource: "deterministic-fallback",
-			physicalName: name,
-			expression: sql(match[2] ?? "true", namespace, table, name),
-			dialect: sqliteExtension({ source: "create-sql" })
-		};
-		constraints.push(check);
-	});
-	return constraints;
-}
-function sqliteIndex(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: sqliteExtension({
-				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: sqliteExtension({
-			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, namespace) {
-	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 first = group[0];
-		const physicalName = `foreign_key_${table.physicalName}_${key}`;
-		return {
-			kind: "foreign-key",
-			id: stableId(physicalName),
-			identitySource: "deterministic-fallback",
-			physicalName,
-			columns: group.sort((left, right) => (number(left.seq) ?? 0) - (number(right.seq) ?? 0)).map((row) => text(row.source_column) ?? "unknown"),
-			target: {
-				table: text(first.target_table) ?? "unknown",
-				columns: group.map((row) => text(row.target_column) ?? "unknown")
-			},
-			onUpdate: action(first.on_update),
-			onDelete: action(first.on_delete),
-			match: match(first.match),
-			dialect: sqliteExtension({ foreignKeyId: key }),
-			reference: reference("constraint", physicalName, namespace, "pragma_foreign_key_list", "id", key)
-		};
-	});
-}
-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 { IntrospectionError, createCompleteIntrospectionCatalog, createIntrospectionDiagnostic, freezeIntrospectionCatalog, hasIntrospectionErrors, introspectedPhysicalIdentityPolicy, mapCatalogToCompleteSnapshot, mapCatalogToSnapshot, mapCatalogToSnapshotV2, mysqlChecksQuery, mysqlCollationsQuery, mysqlColumnsQuery, mysqlEventsQuery, mysqlKeyUsageQuery, mysqlPartitionsQuery, mysqlRoutineParametersQuery, mysqlRoutinesQuery, mysqlServerQuery, mysqlStatisticsQuery, mysqlTablesQuery, mysqlTriggersQuery, mysqlViewsQuery, postgresCollationsQuery, postgresColumnsQuery, postgresConstraintsQuery, postgresDomainConstraintsQuery, postgresDomainsQuery, postgresEnumsQuery, postgresExtensionsQuery, postgresIdentitiesQuery, postgresIndexesQuery, postgresMetadataQuery, postgresPartitionsQuery, postgresPoliciesQuery, postgresRelationsQuery, postgresRoutineParametersQuery, postgresRoutinesQuery, postgresSequencesQuery, postgresServerQuery, postgresTriggersQuery, postgresViewsQuery, readMysqlCatalog, readPostgresCatalog, readSqliteCatalog, sqliteDatabaseListQuery, sqliteForeignKeyQuery, sqliteIndexInfoQuery, sqliteIndexListQuery, sqliteSchemaQuery, sqliteServerQuery, sqliteTableInfoQuery, sqliteTableListQuery, sqliteTempSchemaQuery, toIntrospectionCatalog };
+export { IntrospectionError, createCompleteIntrospectionCatalog, createIntrospectionDiagnostic, freezeIntrospectionCatalog, hasIntrospectionErrors, introspectedPhysicalIdentityPolicy, mapCatalogToCompleteSnapshot, mapCatalogToSnapshot, mapCatalogToSnapshotV2, toIntrospectionCatalog };