qubu 0.0.0 → 0.3.4

package/dist/introspection.mjs

@@ -0,0 +1,4341 @@
+import { a as toSnapshotJsonValue } from "./canonical-BbnqavJm.mjs";
+import { a as hasIntrospectionErrors, i as createIntrospectionDiagnostic, n as introspectedPhysicalIdentityPolicy, r as IntrospectionError, t as mapCatalogToSnapshot } from "./snapshot-CWPgzxNx.mjs";
+import { n as assertCompleteSchemaSnapshot } from "./complete-D5Djh-zo.mjs";
+import "./snapshot.mjs";
+//#region src/introspection/catalog.ts
+/**
+* Materialize every optional object-family collection and deeply freeze the
+* normalized catalog. Catalog text and extension data remain values; this
+* helper never evaluates SQL or assigns persisted logical identities.
+*/
+function createCompleteIntrospectionCatalog(catalog) {
+	return deepFreeze({
+		dialect: catalog.dialect,
+		server: catalog.server,
+		capabilities: catalog.capabilities ?? catalog.server.capabilities,
+		namespace: catalog.namespace,
+		tables: sortTables(catalog.tables),
+		views: sortObjects(catalog.views ?? []),
+		sequences: sortObjects(catalog.sequences ?? []),
+		enums: sortObjects(catalog.enums ?? []),
+		domains: sortObjects(catalog.domains ?? []),
+		collations: sortObjects(catalog.collations ?? []),
+		triggers: sortObjects(catalog.triggers ?? []),
+		routines: sortObjects(catalog.routines ?? []),
+		partitions: sortObjects(catalog.partitions ?? []),
+		policies: sortObjects(catalog.policies ?? []),
+		extensionObjects: sortObjects(catalog.extensionObjects ?? []),
+		deferredObjects: [...catalog.deferredObjects].sort(compareDeferred),
+		opaqueObjects: sortObjects(catalog.opaqueObjects ?? []),
+		comments: [...catalog.comments ?? []].sort(compareId$1),
+		ownership: [...catalog.ownership ?? []].sort(compareId$1),
+		diagnostics: [...catalog.diagnostics]
+	});
+}
+/** Alias for callers that already use the normalized-catalog terminology. */
+const freezeIntrospectionCatalog = createCompleteIntrospectionCatalog;
+/** Convert a complete catalog back to the optional reader-facing contract. */
+function toIntrospectionCatalog(catalog) {
+	return deepFreeze({
+		...catalog,
+		capabilities: catalog.capabilities
+	});
+}
+function sortTables(tables) {
+	return [...tables].map((table) => deepFreeze({
+		...table,
+		columns: [...table.columns].sort(compareColumn),
+		constraints: [...table.constraints].sort(compareId$1),
+		indexes: [...table.indexes].sort(compareId$1)
+	})).sort(compareId$1);
+}
+function sortObjects(objects) {
+	return [...objects].sort(compareId$1);
+}
+function compareId$1(left, right) {
+	return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+function compareDeferred(left, right) {
+	const leftId = left.id ?? left.physicalName;
+	const rightId = right.id ?? right.physicalName;
+	return leftId < rightId ? -1 : leftId > rightId ? 1 : 0;
+}
+function compareColumn(left, right) {
+	return left.ordinalPosition - right.ordinalPosition || compareId$1(left, right);
+}
+/**
+* Freeze nested catalog values without imposing JSON semantics on bigint or
+* opaque driver values. The normalized contract is expected to contain plain
+* records, arrays, and scalar values; unsupported prototypes are retained but
+* still frozen so the operation remains non-destructive.
+*/
+function deepFreeze(value, seen = /* @__PURE__ */ new WeakSet()) {
+	if (value === null || typeof value !== "object") return value;
+	if (seen.has(value)) return value;
+	seen.add(value);
+	if (Array.isArray(value)) for (const item of value) deepFreeze(item, seen);
+	else for (const child of Object.values(value)) deepFreeze(child, seen);
+	return Object.freeze(value);
+}
+//#endregion
+//#region src/introspection/complete-snapshot.ts
+/**
+* Map a normalized catalog to strict Snapshot v2 data. This is intentionally
+* separate from the Snapshot v1 mapper: complete objects are never fabricated
+* as tables, and catalog references remain evidence rather than logical IDs.
+*/
+function mapCatalogToCompleteSnapshot(input) {
+	const catalog = createCompleteIntrospectionCatalog(input);
+	const diagnostics = [...catalog.diagnostics];
+	const tableByPhysicalName = new Map(catalog.tables.map((table) => [table.physicalName, table]));
+	const tables = catalog.tables.map((table) => mapTable(table, catalog.dialect, tableByPhysicalName, diagnostics));
+	const views = catalog.views.map((view) => mapView(view, catalog.dialect));
+	const sequences = catalog.sequences.map((sequence) => mapSequence(sequence, catalog.dialect));
+	const enums = catalog.enums.map((item) => mapEnum(item, catalog.dialect));
+	const domains = catalog.domains.map((domain) => mapDomain(domain, catalog.dialect));
+	const collations = catalog.collations.map((collation) => ({
+		kind: "collation",
+		id: collation.id,
+		physicalName: collation.physicalName,
+		...collation.provider === void 0 ? {} : { provider: collation.provider },
+		...collation.locale === void 0 ? {} : { locale: collation.locale },
+		...collation.deterministic === void 0 ? {} : { deterministic: collation.deterministic },
+		...collation.version === void 0 ? {} : { version: collation.version },
+		...mapMetadata(collation.provenance, collation.dialect, catalog.dialect, collation.reference)
+	}));
+	const triggers = catalog.triggers.map((trigger) => mapTrigger(trigger, catalog.dialect, diagnostics));
+	const routines = catalog.routines.map((routine) => mapRoutine(routine, catalog.dialect));
+	const partitions = catalog.partitions.map((partition) => mapPartition(partition, catalog.dialect));
+	const policies = catalog.policies.map((policy) => mapPolicy(policy, catalog.dialect));
+	const extensions = catalog.extensionObjects.map((extension) => mapExtensionObject(extension, catalog.dialect));
+	const deferredObjects = catalog.deferredObjects.map((object) => mapDeferredObject(object, catalog.dialect));
+	const opaqueObjects = catalog.opaqueObjects.map((object) => mapOpaqueObject(object, catalog.dialect));
+	for (const object of catalogObjectsWithUnknownFields(catalog)) for (const field of object.unknownFields ?? []) opaqueObjects.push(mapUnknownField(object, field, catalog.dialect));
+	const comments = (catalog.comments ?? []).map((comment) => mapComment(comment, catalog.dialect));
+	const ownership = (catalog.ownership ?? []).map((item) => mapOwnership(item, catalog.dialect));
+	for (const object of catalogObjectList(catalog)) {
+		if (object.comment && !comments.some((item) => item.id === object.comment?.id)) comments.push(mapComment(object.comment, catalog.dialect));
+		if (object.ownership && !ownership.some((item) => item.id === object.ownership?.id)) ownership.push(mapOwnership(object.ownership, catalog.dialect));
+	}
+	const snapshot = {
+		format: "qubu-schema",
+		version: 2,
+		dialect: {
+			name: catalog.dialect,
+			version: 1
+		},
+		namingPolicy: {
+			name: introspectedPhysicalIdentityPolicy.name,
+			version: introspectedPhysicalIdentityPolicy.version
+		},
+		namespace: {
+			kind: catalog.namespace.kind,
+			name: catalog.namespace.name,
+			...mapMetadata(catalog.namespace.provenance, catalog.namespace.dialect, catalog.dialect, catalog.namespace.reference)
+		},
+		capabilities: catalog.capabilities,
+		tables: tables.sort(compareId),
+		views: views.sort(compareId),
+		sequences: sequences.sort(compareId),
+		enums: enums.sort(compareId),
+		domains: domains.sort(compareId),
+		collations: collations.sort(compareId),
+		triggers: triggers.sort(compareId),
+		routines: routines.sort(compareId),
+		partitions: partitions.sort(compareId),
+		policies: policies.sort(compareId),
+		extensions: extensions.sort(compareId),
+		deferredObjects: deferredObjects.sort(compareId),
+		opaqueObjects: opaqueObjects.sort(compareId),
+		comments: comments.sort(compareId),
+		ownership: ownership.sort(compareId)
+	};
+	if (diagnostics.some((diagnostic) => diagnostic.severity === "error")) return Object.freeze({
+		ok: false,
+		catalog,
+		diagnostics: Object.freeze(diagnostics),
+		lossy: false
+	});
+	try {
+		const value = assertCompleteSchemaSnapshot(snapshot);
+		return Object.freeze({
+			ok: true,
+			catalog,
+			snapshot: value,
+			diagnostics: Object.freeze(diagnostics),
+			lossy: false
+		});
+	} catch (error) {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "invalid-catalog-row",
+			message: error instanceof Error ? `Catalog facts could not form Snapshot v2: ${error.message}` : "Catalog facts could not form Snapshot v2",
+			path: [],
+			remediation: "Inspect the catalog diagnostics and complete object mappings."
+		}));
+		return Object.freeze({
+			ok: false,
+			catalog,
+			diagnostics: Object.freeze(diagnostics),
+			lossy: false
+		});
+	}
+}
+/** Numbered alias for callers that keep both snapshot mappers available. */
+const mapCatalogToSnapshotV2 = mapCatalogToCompleteSnapshot;
+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);
+	return {
+		kind: "table",
+		id: table.id,
+		physicalName: table.physicalName,
+		columns,
+		constraints,
+		indexes,
+		...mapMetadata(table.provenance, table.dialect, dialect, table.reference)
+	};
+}
+function mapColumn(column, dialect) {
+	const defaultValue = column.default ? mapValueFact(column.default) : void 0;
+	const generatedColumn = column.generated ? column.generated.mode === "unknown" ? { kind: "external" } : {
+		kind: "expression",
+		expression: mapExpression(column.generated.expression),
+		mode: column.generated.mode
+	} : void 0;
+	const identity = column.identity ? mapIdentity(column.identity, dialect) : void 0;
+	return {
+		kind: "column",
+		id: column.id,
+		physicalName: column.physicalName,
+		ordinalPosition: column.ordinalPosition,
+		nullable: column.nullable,
+		hasDefault: defaultValue !== void 0 || generatedColumn !== void 0 || identity !== void 0,
+		generated: generatedColumn !== void 0,
+		storage: mapStorage(column.storage, dialect),
+		...defaultValue === void 0 ? {} : { default: defaultValue },
+		...generatedColumn === void 0 ? {} : { generatedColumn },
+		...identity === void 0 ? {} : { identity },
+		...column.onUpdate === void 0 ? {} : { onUpdate: mapExpression(column.onUpdate) },
+		...mapMetadata(column.provenance, column.dialect, dialect, column.reference)
+	};
+}
+function mapConstraint(constraint, dialect, columns, tables, diagnostics) {
+	const physicalName = constraint.physicalName ?? constraint.id;
+	const common = {
+		id: constraint.id,
+		physicalName,
+		...mapMetadata(constraint.provenance, constraint.dialect, dialect, constraint.reference)
+	};
+	const mappedColumns = constraint.kind === "check" ? void 0 : constraint.columns.map((column) => {
+		const id = columns.get(column);
+		if (id !== void 0) return id;
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "unresolved-reference",
+			message: `Constraint column ${column} was not found`,
+			path: [constraint.id, "columns"]
+		}));
+		return column;
+	});
+	if (constraint.kind === "check") return {
+		kind: "check",
+		...common,
+		expression: mapExpression(constraint.expression),
+		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
+	};
+	if (constraint.kind === "primary-key") return {
+		kind: "primary-key",
+		...common,
+		columns: mappedColumns ?? [],
+		...constraint.backingIndex === void 0 ? {} : { backingIndex: mapReference(constraint.backingIndex) },
+		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
+	};
+	if (constraint.kind === "unique") return {
+		kind: "unique-constraint",
+		...common,
+		columns: mappedColumns ?? [],
+		nulls: constraint.nulls,
+		...constraint.backingIndex === void 0 ? {} : { backingIndex: mapReference(constraint.backingIndex) },
+		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
+	};
+	const targetTable = tables.get(constraint.target.table);
+	const targetId = targetTable?.id;
+	if (targetId === void 0) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "error",
+		code: "unresolved-reference",
+		message: `Foreign-key target table ${constraint.target.table} was not found`,
+		path: [
+			constraint.id,
+			"target",
+			"table"
+		]
+	}));
+	const targetColumns = targetTable ? constraint.target.columns.map((column) => targetTable.columns.find((item) => item.physicalName === column)?.id ?? column) : constraint.target.columns;
+	return {
+		kind: "foreign-key",
+		...common,
+		columns: mappedColumns ?? [],
+		target: {
+			table: {
+				kind: "table",
+				id: targetId ?? constraint.target.table
+			},
+			columns: targetColumns
+		},
+		...constraint.onUpdate === void 0 ? {} : { onUpdate: constraint.onUpdate },
+		...constraint.onDelete === void 0 ? {} : { onDelete: constraint.onDelete },
+		...constraint.match === void 0 ? {} : { match: constraint.match },
+		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+		...constraint.validated === void 0 ? {} : { validated: constraint.validated }
+	};
+}
+function mapIndex$1(index, dialect, columns) {
+	return {
+		kind: "index",
+		id: index.id,
+		physicalName: index.physicalName ?? index.id,
+		terms: index.terms.map((term) => mapIndexTerm(term, columns)).filter((term) => term !== void 0).sort((left, right) => left.position - right.position),
+		unique: index.unique,
+		candidateKey: index.unique,
+		...index.predicate === void 0 ? {} : { predicate: mapExpression(index.predicate) },
+		...index.includedColumns === void 0 ? {} : { includedColumns: index.includedColumns.map((column) => columns.get(column) ?? column) },
+		...index.backingConstraint === void 0 ? {} : { backingConstraint: mapReference(index.backingConstraint) },
+		...index.method === void 0 ? {} : { method: index.method },
+		...mapMetadata(void 0, index.dialect, dialect, index.reference)
+	};
+}
+function mapIndexTerm(term, columns) {
+	if (term.kind === "column") return {
+		kind: "column",
+		column: columns.get(term.column) ?? term.column,
+		position: term.position,
+		...term.direction === void 0 ? {} : { direction: term.direction },
+		...term.nulls === void 0 ? {} : { nulls: term.nulls },
+		...term.prefixLength === void 0 ? {} : { prefixLength: mapValueFact(term.prefixLength) },
+		...term.operatorClass === void 0 ? {} : { operatorClass: term.operatorClass }
+	};
+	return {
+		kind: "expression",
+		expression: mapExpression(term.expression),
+		position: term.position,
+		...term.direction === void 0 ? {} : { direction: term.direction },
+		...term.nulls === void 0 ? {} : { nulls: term.nulls },
+		...term.operatorClass === void 0 ? {} : { operatorClass: term.operatorClass }
+	};
+}
+function mapView(view, dialect) {
+	return {
+		kind: view.kind,
+		id: view.id,
+		physicalName: view.physicalName,
+		columns: view.columns.map((column) => mapColumn(column, dialect)).sort(compareId),
+		definition: mapExpression(view.definition),
+		...view.dependencies === void 0 ? {} : { dependencies: view.dependencies.map(mapReference) },
+		...view.checkOption === void 0 ? {} : { checkOption: view.checkOption },
+		...view.securityBarrier === void 0 ? {} : { securityBarrier: view.securityBarrier },
+		...view.securityInvoker === void 0 ? {} : { securityInvoker: view.securityInvoker },
+		...mapMetadata(view.provenance, view.dialect, dialect, view.reference)
+	};
+}
+function mapSequence(sequence, dialect) {
+	return {
+		kind: "sequence",
+		id: sequence.id,
+		physicalName: sequence.physicalName,
+		...sequence.storage === void 0 ? {} : { storage: mapStorage(sequence.storage, dialect) },
+		...sequence.start === void 0 ? {} : { start: mapValueFact(sequence.start) },
+		...sequence.increment === void 0 ? {} : { increment: mapValueFact(sequence.increment) },
+		...sequence.minimum === void 0 ? {} : { minimum: mapValueFact(sequence.minimum) },
+		...sequence.maximum === void 0 ? {} : { maximum: mapValueFact(sequence.maximum) },
+		...sequence.cache === void 0 ? {} : { cache: mapValueFact(sequence.cache) },
+		...sequence.cycle === void 0 ? {} : { cycle: sequence.cycle },
+		...sequence.ownedBy === void 0 ? {} : { ownedBy: mapReference(sequence.ownedBy) },
+		...sequence.identity === void 0 ? {} : { identity: mapIdentity(sequence.identity, dialect) },
+		...mapMetadata(sequence.provenance, sequence.dialect, dialect, sequence.reference)
+	};
+}
+function mapEnum(item, dialect) {
+	return {
+		kind: "enum",
+		id: item.id,
+		physicalName: item.physicalName,
+		values: [...item.values].sort((left, right) => left.ordinalPosition - right.ordinalPosition).map((value) => ({
+			value: value.value,
+			ordinalPosition: value.ordinalPosition,
+			...value.provenance === void 0 ? {} : { provenance: mapProvenance(value.provenance) }
+		})),
+		...mapMetadata(item.provenance, item.dialect, dialect, item.reference)
+	};
+}
+function mapDomain(domain, dialect) {
+	return {
+		kind: "domain",
+		id: domain.id,
+		physicalName: domain.physicalName,
+		storage: mapStorage(domain.storage, dialect),
+		...domain.nullable === void 0 ? {} : { nullable: domain.nullable },
+		...domain.default === void 0 ? {} : { default: mapValueFact(domain.default) },
+		...domain.constraints === void 0 ? {} : { constraints: domain.constraints.map((constraint) => mapCheckConstraint(constraint, dialect)).sort(compareId) },
+		...mapMetadata(domain.provenance, domain.dialect, dialect, domain.reference)
+	};
+}
+function mapCheckConstraint(constraint, dialect) {
+	return {
+		kind: "check",
+		id: constraint.id,
+		physicalName: constraint.physicalName ?? constraint.id,
+		expression: mapExpression(constraint.expression),
+		...constraint.deferrable === void 0 ? {} : { deferrable: constraint.deferrable },
+		...constraint.initially === void 0 ? {} : { initially: constraint.initially },
+		...constraint.validated === void 0 ? {} : { validated: constraint.validated },
+		...mapMetadata(constraint.provenance, constraint.dialect, dialect, constraint.reference)
+	};
+}
+function mapTrigger(trigger, dialect, _diagnostics) {
+	return {
+		kind: "trigger",
+		id: trigger.id,
+		physicalName: trigger.physicalName,
+		table: mapReference(trigger.table),
+		timing: trigger.timing,
+		events: [...trigger.events].sort(),
+		...trigger.orientation === void 0 ? {} : { orientation: trigger.orientation },
+		...trigger.condition === void 0 ? {} : { condition: mapExpression(trigger.condition) },
+		body: mapExpression(trigger.body),
+		...trigger.enabled === void 0 ? {} : { enabled: trigger.enabled },
+		...mapMetadata(trigger.provenance, trigger.dialect, dialect, trigger.reference)
+	};
+}
+function mapRoutine(routine, dialect) {
+	return {
+		kind: "routine",
+		id: routine.id,
+		physicalName: routine.physicalName,
+		routineKind: routine.routineKind,
+		parameters: [...routine.parameters].sort((left, right) => left.ordinalPosition - right.ordinalPosition).map((parameter) => mapRoutineParameter(parameter, dialect)),
+		...routine.returnType === void 0 ? {} : { returnType: mapStorage(routine.returnType, dialect) },
+		...routine.language === void 0 ? {} : { language: routine.language },
+		...routine.body === void 0 ? {} : { body: mapExpression(routine.body) },
+		...routine.volatility === void 0 ? {} : { volatility: routine.volatility },
+		...routine.parallel === void 0 ? {} : { parallel: routine.parallel },
+		...routine.security === void 0 ? {} : { security: routine.security },
+		...routine.dependencies === void 0 ? {} : { dependencies: routine.dependencies.map(mapReference) },
+		...mapMetadata(routine.provenance, routine.dialect, dialect, routine.reference)
+	};
+}
+function mapRoutineParameter(parameter, dialect) {
+	return {
+		...parameter.name === void 0 ? {} : { name: parameter.name },
+		...parameter.mode === void 0 ? {} : { mode: parameter.mode },
+		storage: mapStorage(parameter.storage, dialect),
+		...parameter.default === void 0 ? {} : { default: mapValueFact(parameter.default) },
+		ordinalPosition: parameter.ordinalPosition
+	};
+}
+function mapPartition(partition, dialect) {
+	return {
+		kind: "partition",
+		id: partition.id,
+		physicalName: partition.physicalName,
+		parent: mapReference(partition.parent),
+		strategy: partition.strategy,
+		...partition.keyColumns === void 0 ? {} : { keyColumns: [...partition.keyColumns] },
+		...partition.bound === void 0 ? {} : { bound: mapExpression(partition.bound) },
+		...partition.default === void 0 ? {} : { default: partition.default },
+		...mapMetadata(partition.provenance, partition.dialect, dialect, partition.reference)
+	};
+}
+function mapPolicy(policy, dialect) {
+	return {
+		kind: "policy",
+		id: policy.id,
+		physicalName: policy.physicalName,
+		table: mapReference(policy.table),
+		command: policy.command,
+		...policy.roles === void 0 ? {} : { roles: [...policy.roles].sort() },
+		...policy.permissive === void 0 ? {} : { permissive: policy.permissive },
+		...policy.using === void 0 ? {} : { using: mapExpression(policy.using) },
+		...policy.check === void 0 ? {} : { check: mapExpression(policy.check) },
+		...mapMetadata(policy.provenance, policy.dialect, dialect, policy.reference)
+	};
+}
+function mapExtensionObject(extension, dialect) {
+	return {
+		kind: "extension",
+		id: extension.id,
+		physicalName: extension.physicalName,
+		extensionName: extension.extensionName,
+		...extension.extensionVersion === void 0 ? {} : { extensionVersion: extension.extensionVersion },
+		...extension.schema === void 0 ? {} : { schema: extension.schema },
+		data: toSnapshotJsonValue(extension.data),
+		...extension.configuration === void 0 ? {} : { configuration: toSnapshotJsonValue(extension.configuration) },
+		...mapMetadata(extension.provenance, extension.dialect, dialect, extension.reference)
+	};
+}
+function mapDeferredObject(object, dialect) {
+	const data = object.unknownFields ? Object.fromEntries(object.unknownFields.map((field) => [field.name, toSnapshotJsonValue(isCatalogSqlExpression(field.value) ? field.value.text : field.value)])) : void 0;
+	return {
+		kind: "deferred-object",
+		id: object.id ?? `deferred:${object.objectKind}:${object.physicalName}`,
+		objectKind: object.objectKind,
+		physicalName: object.physicalName,
+		...data === void 0 ? {} : { data: toSnapshotJsonValue(data) },
+		...mapMetadata(object.provenance, object.dialect, dialect, object.reference)
+	};
+}
+function mapOpaqueObject(object, dialect) {
+	return {
+		kind: "opaque-object",
+		id: object.id,
+		objectKind: object.objectKind,
+		physicalName: object.physicalName,
+		data: toSnapshotJsonValue(object.data),
+		...object.sql === void 0 ? {} : { sql: mapExpression(object.sql) },
+		...mapMetadata(object.provenance, object.dialect, dialect, object.reference)
+	};
+}
+function mapComment(comment, dialect) {
+	return {
+		kind: "comment",
+		id: comment.id,
+		physicalName: comment.reference?.name ?? comment.id,
+		object: mapReference(comment.object),
+		text: comment.text,
+		...mapMetadata(comment.provenance, comment.dialect, dialect, comment.reference)
+	};
+}
+function mapOwnership(ownership, dialect) {
+	return {
+		kind: "ownership",
+		id: ownership.id,
+		physicalName: ownership.reference?.name ?? ownership.id,
+		object: mapReference(ownership.object),
+		owner: ownership.owner,
+		...mapMetadata(ownership.provenance, ownership.dialect, dialect, ownership.reference)
+	};
+}
+function mapStorage(storage, dialect) {
+	if (storage.portable !== void 0) return {
+		kind: "portable",
+		type: storage.portable.type
+	};
+	return {
+		kind: "native",
+		dialect,
+		type: storage.nativeType
+	};
+}
+function mapValueFact(value) {
+	if (value.kind === "literal") return {
+		kind: "literal",
+		value: mapLiteral(value)
+	};
+	return {
+		kind: "expression",
+		expression: mapExpression(value.expression)
+	};
+}
+function mapLiteral(value) {
+	if (value.value === null) return { kind: "null" };
+	if (typeof value.value === "boolean") return {
+		kind: "boolean",
+		value: value.value
+	};
+	if (typeof value.value === "bigint") return {
+		kind: "bigint",
+		value: value.value.toString()
+	};
+	if (typeof value.value === "number") return {
+		kind: "number",
+		value: String(value.value)
+	};
+	return {
+		kind: "string",
+		value: value.value
+	};
+}
+function mapIdentity(identity, dialect) {
+	return {
+		kind: "identity",
+		generation: identity.generation,
+		options: Object.fromEntries(Object.entries(identity.options).map(([key, value]) => [key, mapValueFact(value)])),
+		...mapMetadata(void 0, identity.dialect, dialect)
+	};
+}
+function mapExpression(value) {
+	return {
+		kind: "expression",
+		expressionKind: "unsafe",
+		sql: value.text.replace(/\r\n?/g, "\n").trim(),
+		dialect: value.dialect
+	};
+}
+function mapMetadata(provenance, extension, dialect, reference) {
+	const mappedProvenance = provenance ? mapProvenance(provenance) : void 0;
+	const mappedExtension = extension ? {
+		dialect: extension.dialect,
+		version: extension.version,
+		data: toSnapshotJsonValue(extension.data)
+	} : void 0;
+	const physicalReference = reference ? {
+		kind: reference.kind,
+		...reference.namespace === void 0 ? {} : { namespace: reference.namespace },
+		...reference.table === void 0 ? {} : { table: reference.table },
+		name: reference.name
+	} : void 0;
+	return {
+		...mappedProvenance === void 0 ? {} : { provenance: mappedProvenance },
+		...physicalReference === void 0 ? {} : { physicalReference },
+		...mappedExtension === void 0 ? {} : { dialect: mappedExtension }
+	};
+}
+function mapProvenance(value) {
+	return {
+		kind: value.kind,
+		dialect: value.dialect,
+		...value.path === void 0 ? {} : { path: [...value.path] }
+	};
+}
+function mapReference(reference) {
+	return {
+		kind: reference.kind,
+		id: reference.id
+	};
+}
+function catalogObjectList(catalog) {
+	const topLevel = [
+		catalog.namespace,
+		...catalog.tables,
+		...catalog.views,
+		...catalog.sequences,
+		...catalog.enums,
+		...catalog.domains,
+		...catalog.collations,
+		...catalog.triggers,
+		...catalog.routines,
+		...catalog.partitions,
+		...catalog.policies,
+		...catalog.extensionObjects,
+		...catalog.deferredObjects,
+		...catalog.opaqueObjects,
+		...catalog.comments,
+		...catalog.ownership
+	];
+	const nested = [
+		...catalog.tables.flatMap((table) => [
+			...table.columns,
+			...table.constraints,
+			...table.indexes
+		]),
+		...catalog.views.flatMap((view) => view.columns),
+		...catalog.domains.flatMap((domain) => domain.constraints ?? [])
+	];
+	return [...topLevel, ...nested];
+}
+function catalogObjectsWithUnknownFields(catalog) {
+	return catalogObjectList(catalog);
+}
+function mapUnknownField(object, field, dialect) {
+	const sql = isCatalogSqlExpression(field.value) ? mapExpression(field.value) : void 0;
+	const value = isCatalogSqlExpression(field.value) ? field.value.text : field.value;
+	return {
+		kind: "opaque-object",
+		id: `unknown:${object.kind}:${object.id ?? object.physicalName ?? "object"}:${field.name}`,
+		objectKind: "unknown-field",
+		physicalName: object.physicalName ?? object.id ?? field.name,
+		data: toSnapshotJsonValue({
+			ownerKind: object.kind,
+			ownerId: object.id ?? object.physicalName ?? field.name,
+			field: field.name,
+			value
+		}),
+		...sql === void 0 ? {} : { sql },
+		...mapMetadata(field.provenance, void 0, dialect)
+	};
+}
+function compareId(left, right) {
+	return left.id < right.id ? -1 : left.id > right.id ? 1 : 0;
+}
+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 void 0;
+	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 void 0;
+	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 void 0;
+	return literalFact(value);
+}
+function literalFact(value) {
+	if (value === void 0) return void 0;
+	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 void 0;
+	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 void 0;
+	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}`), 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 void 0;
+	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 void 0;
+	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 void 0;
+	const open = sqlText.indexOf("(", sqlText.search(/\bON\b/i));
+	if (open < 0) return void 0;
+	const close = matchingParen(sqlText, open);
+	if (close < 0) return void 0;
+	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 primary = {
+			kind: "primary-key",
+			id: stableId(`primary_${table.physicalName}`),
+			identitySource: "deterministic-fallback",
+			physicalName: `primary_${table.physicalName}`,
+			columns: primaryColumns.map((column) => column.physicalName),
+			dialect: sqliteExtension({ source: "pragma_table_xinfo" }),
+			reference: reference("constraint", `primary_${table.physicalName}`, namespace, "sqlite_schema", "tbl_name")
+		};
+		constraints.push(primary);
+	}
+	[...sqlText?.matchAll(/CHECK\s*\(([^()]*(?:\([^()]*\)[^()]*)*)\)/gi) ?? []].forEach((match, index) => {
+		const name = `check_${index}_${table.physicalName}`;
+		const check = {
+			kind: "check",
+			id: stableId(name),
+			identitySource: "deterministic-fallback",
+			physicalName: name,
+			expression: sql(match[1] ?? "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 void 0;
+	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 constraintName = internalName ? `unique_${table.physicalName}_${termNames.join("_") || "constraint"}` : physicalName;
+		return {
+			kind: "unique",
+			id: stableId(constraintName),
+			identitySource: internalName ? "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 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 void 0;
+	const open = sqlText.indexOf("(");
+	if (open < 0) return void 0;
+	const close = matchingParen(sqlText, open);
+	if (close < 0) return void 0;
+	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 void 0;
+		const generatedOpen = definition.indexOf("(", generated.index);
+		if (generatedOpen < 0) return void 0;
+		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 };