qubu 0.6.0 → 0.6.2

package/dist/introspection/postgres.mjs

@@ -0,0 +1,1889 @@
+import { n as createIntrospectionDiagnostic } from "../diagnostics-I9vVtXkc.mjs";
+//#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 readCatalog(connection, options) {
+	const diagnostics = [];
+	const deferredObjects = [];
+	const opaqueObjects = [];
+	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(options.namespace, diagnostics);
+	}
+	const server = serverInfo((await query(connection, postgresServerQuery, [], options, diagnostics, "server"))[0], diagnostics);
+	const relationObjects = (await query(connection, postgresRelationsQuery, [options.namespace], options, diagnostics, "relations")).filter((row) => {
+		const kind = text(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(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(connection, postgresColumnsQuery, [options.namespace], options, diagnostics, "columns");
+	const identityRows = await query(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(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(row, view, options.namespace));
+	const indexRows = await query(connection, postgresIndexesQuery, [options.namespace], options, diagnostics, "indexes");
+	const indexReferences = /* @__PURE__ */ new Map();
+	for (const row of indexRows) {
+		const indexOid = text(row.index_oid);
+		const physicalName = text(row.physical_name);
+		const ownerTable = tableByOid.get(text(row.table_oid));
+		if (indexOid && physicalName) indexReferences.set(`pg_class:${indexOid}`, {
+			kind: "index",
+			id: stableId(physicalName),
+			physicalName,
+			...ownerTable === void 0 ? {} : { owner: {
+				kind: "table",
+				id: ownerTable.id
+			} },
+			reference: reference("index", physicalName, options.namespace, "pg_class", "oid", row.index_oid)
+		});
+	}
+	const constraintsByTable = groupBy(await query(connection, (server.parsedVersion?.major ?? 0) >= 15 ? postgresConstraintsQuery : postgresConstraintsQueryWithoutNullsNotDistinct, [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]));
+		const constraints = [];
+		for (const value of rows.map((row) => constraint(row, table, columnsByNumber, tableByOid, options.namespace, diagnostics, indexReferences))) {
+			if (value === void 0) continue;
+			if (value.kind === "opaque-object") opaqueObjects.push(value);
+			else constraints.push(value);
+		}
+		table.constraints = constraints;
+	}
+	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, diagnostics, opaqueObjects);
+	const sequences = (await query(connection, postgresSequencesQuery, [options.namespace], options, diagnostics, "sequences")).map((row) => sequenceObject(row, options.namespace, tableByOid, diagnostics));
+	const enums = mapEnums(await query(connection, postgresEnumsQuery, [options.namespace], options, diagnostics, "enums"), options.namespace);
+	const domains = mapDomains(await query(connection, postgresDomainsQuery, [options.namespace], options, diagnostics, "domains"), await query(connection, postgresDomainConstraintsQuery, [options.namespace], options, diagnostics, "domain-constraints"), options.namespace, opaqueObjects, diagnostics);
+	const collations = (await query(connection, postgresCollationsQuery, [options.namespace], options, diagnostics, "collations")).map((row) => collationObject(row, options.namespace));
+	const triggerRows = await query(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(connection, postgresRoutinesQuery, [options.namespace], options, diagnostics, "routines"), await query(connection, postgresRoutineParametersQuery, [options.namespace], options, diagnostics, "routine-parameters"), options.namespace, diagnostics);
+	const partitionRows = await query(connection, postgresPartitionsQuery, [options.namespace], options, diagnostics, "partitions");
+	const partitions = [];
+	for (const row of partitionRows) {
+		const value = partitionObject(row, options.namespace, tableByOid, diagnostics);
+		if (value === void 0) continue;
+		if (value.kind === "partition") partitions.push(value);
+		else if (value.kind === "deferred-object") deferredObjects.push(value);
+		else opaqueObjects.push(value);
+	}
+	const policies = (await query(connection, postgresPoliciesQuery, [options.namespace], options, diagnostics, "policies")).map((row) => policyObject(row, options.namespace, tableByOid, diagnostics)).filter((value) => value !== void 0);
+	const extensionObjects = (await query(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));
+	deferredObjects.push(...relationObjects.filter((row) => {
+		const relkind = text(row.relkind);
+		return relkind === "f" || (relkind === "v" || relkind === "m" || relkind === "S") && !typedRelationOids.has(row.oid === void 0 ? void 0 : text(row.oid));
+	}).map((row) => deferredObject(row, text(row.relkind) === "f" ? "foreign-table" : text(row.relkind) === "v" ? "view" : text(row.relkind) === "m" ? "materialized-view" : "sequence")));
+	deferredObjects.push(...triggerDeferredObjects);
+	opaqueObjects.push(...relationObjects.filter((row) => {
+		const kind = text(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(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("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
+`;
+/** Constraint metadata for PostgreSQL versions before pg_index.indnullsnotdistinct. */
+const postgresConstraintsQueryWithoutNullsNotDistinct = `
+  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,
+         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
+`;
+/** Constraint metadata for PostgreSQL versions that expose nulls-not-distinct indexes. */
+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_partkeydef(parent.oid) AS key_definition,
+         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(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(row, diagnostics) {
+	const rawVersion = text(row?.server_version) ?? "unknown";
+	const numericVersion = number(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(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(row.physical_name) ?? "unnamed_view";
+	const kind = row.relkind === "m" ? "materialized-view" : "view";
+	const physicalReference = reference(kind, physicalName, text(row.namespace) ?? namespace, "pg_class", "oid", row.oid);
+	const definition = text(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);
+	}
+	const options = stringArray(row.reloptions);
+	const checkOption = (() => {
+		const value = text(row.check_option)?.toLowerCase();
+		return value === "none" || value === "local" || value === "cascaded" ? value : void 0;
+	})();
+	return {
+		kind,
+		id: stableId(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(tableOid) ?? "unknown"}:${number(ordinalPosition) ?? 0}`;
+}
+function compareOrdinal(left, right) {
+	return (number(left.ordinal_position) ?? 0) - (number(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(row.seqcycle)
+	};
+	if (text(row.sequence_type) !== void 0) options.type = {
+		kind: "literal",
+		value: text(row.sequence_type)
+	};
+	return options;
+}
+function sequenceObject(row, namespace, tableByOid, diagnostics) {
+	const physicalName = text(row.physical_name) ?? `sequence_${text(row.oid) ?? "unknown"}`;
+	const physicalReference = reference("sequence", physicalName, text(row.namespace) ?? namespace, "pg_class", "oid", row.oid);
+	const ownedTable = tableByOid.get(text(row.owned_table_oid));
+	const ownedBy = ownedTable ? {
+		kind: "table",
+		id: ownedTable.id
+	} : void 0;
+	const ownedTableOid = text(row.owned_table_oid);
+	const ownedColumnPosition = number(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(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(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(row.oid) ?? text(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(first.physical_name) ?? `enum_${text(first.oid) ?? "unknown"}`;
+		const physicalReference = reference("enum", physicalName, text(first.namespace) ?? namespace, "pg_type", "oid", first.oid);
+		const values = [...enumRows].sort((left, right) => (number(left.ordinal_position) ?? 0) - (number(right.ordinal_position) ?? 0)).map((row, index) => ({
+			value: text(row.value) ?? "",
+			ordinalPosition: index + 1,
+			provenance: {
+				kind: "catalog",
+				dialect: "postgresql",
+				reference: reference("enum", physicalName, text(row.namespace) ?? namespace, "pg_enum", "oid", row.value_oid)
+			}
+		}));
+		return {
+			kind: "enum",
+			id: stableId(physicalName),
+			identitySource: "physical-name",
+			physicalName,
+			values,
+			reference: physicalReference
+		};
+	});
+}
+function mapDomains(rows, constraintRows, namespace, opaqueObjects, diagnostics) {
+	const constraintsByDomain = groupBy(constraintRows, (row) => text(row.domain_oid) ?? "unknown");
+	return rows.map((row) => {
+		const physicalName = text(row.physical_name) ?? `domain_${text(row.oid) ?? "unknown"}`;
+		const physicalReference = reference("domain", physicalName, text(row.namespace) ?? namespace, "pg_type", "oid", row.oid);
+		const domainConstraints = (constraintsByDomain.get(text(row.oid)) ?? []).map((constraintRow) => {
+			const constraintName = text(constraintRow.physical_name) ?? `domain_constraint_${text(constraintRow.oid) ?? "unknown"}`;
+			const constraintReference = reference("constraint", constraintName, text(row.namespace) ?? namespace, "pg_constraint", "oid", constraintRow.oid);
+			const definition = text(constraintRow.definition);
+			if (definition === void 0 || definition.trim() === "") {
+				diagnostics.push(createIntrospectionDiagnostic({
+					severity: "warning",
+					code: "unmodeled-object",
+					message: `PostgreSQL domain constraint ${constraintName} has no recoverable definition`,
+					path: [
+						"domains",
+						physicalName,
+						"constraints",
+						constraintName
+					],
+					physicalReference: constraintReference,
+					remediation: "Inspect the opaque domain constraint before using it as migration input."
+				}));
+				opaqueObjects.push(opaqueDomainConstraint(physicalName, constraintName, constraintReference, void 0));
+				return;
+			}
+			return {
+				kind: "check",
+				id: stableId(constraintName),
+				identitySource: "physical-name",
+				physicalName: constraintName,
+				expression: expression(definition, "decompiler", constraintReference),
+				deferrable: constraintRow.condeferrable === void 0 ? void 0 : boolean(constraintRow.condeferrable),
+				initially: constraintRow.condeferred === void 0 ? void 0 : boolean(constraintRow.condeferred) ? "deferred" : "immediate",
+				validated: constraintRow.convalidated === void 0 ? void 0 : boolean(constraintRow.convalidated),
+				reference: constraintReference
+			};
+		}).filter((value) => value !== void 0);
+		const defaultValue = domainDefault(row.default_expression, physicalReference);
+		return {
+			kind: "domain",
+			id: stableId(physicalName),
+			identitySource: "physical-name",
+			physicalName,
+			storage: storage(row.native_type),
+			...row.nullable === void 0 || row.nullable === null ? {} : { nullable: boolean(row.nullable) },
+			...defaultValue === void 0 ? {} : { default: defaultValue },
+			...domainConstraints.length === 0 ? {} : { constraints: domainConstraints },
+			reference: physicalReference
+		};
+	});
+}
+function opaqueDomainConstraint(domainName, constraintName, physicalReference, definition) {
+	return {
+		kind: "opaque-object",
+		id: stableId(`domain-constraint:${domainName}:${constraintName}`),
+		identitySource: "physical-name",
+		objectKind: "domain-constraint",
+		physicalName: constraintName,
+		data: {
+			domain: domainName,
+			definitionAvailable: definition !== void 0
+		},
+		...definition === void 0 ? {} : { sql: expression(definition, "decompiler", physicalReference) },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "postgresql",
+			reference: physicalReference
+		}
+	};
+}
+function domainDefault(value, physicalReference) {
+	const textValue = text(value);
+	if (textValue === void 0 || textValue.trim() === "") return;
+	const trimmed = textValue.trim();
+	if (/^NULL$/i.test(trimmed)) return {
+		kind: "literal",
+		value: null
+	};
+	if (/^TRUE$/i.test(trimmed)) return {
+		kind: "literal",
+		value: true
+	};
+	if (/^FALSE$/i.test(trimmed)) return {
+		kind: "literal",
+		value: false
+	};
+	if (/^[+-]?\d+$/.test(trimmed)) {
+		const fact = literalFact(trimmed);
+		if (fact !== void 0) return fact;
+	}
+	if (/^[+-]?\d+\.\d+$/.test(trimmed)) {
+		const fact = literalFact(trimmed);
+		if (fact?.value !== void 0 && typeof fact.value === "number" && canonicalDecimal(trimmed) === canonicalDecimal(String(fact.value))) return fact;
+	}
+	if (trimmed.match(/^'(?:''|[^'])*'$/)) return {
+		kind: "literal",
+		value: trimmed.slice(1, -1).replace(/''/g, "'")
+	};
+	return {
+		kind: "expression",
+		expression: expression(textValue, "catalog", physicalReference)
+	};
+}
+function canonicalDecimal(value) {
+	const match = value.match(/^([+-]?)(\d+)(?:\.(\d+))?$/);
+	if (!match) return;
+	const sign = match[1] === "-" ? "-" : "";
+	const integer = match[2].replace(/^0+(?=\d)/, "");
+	const fraction = (match[3] ?? "").replace(/0+$/, "");
+	return `${sign}${integer}${fraction === "" ? "" : `.${fraction}`}`;
+}
+function collationObject(row, namespace) {
+	const physicalName = text(row.physical_name) ?? `collation_${text(row.oid) ?? "unknown"}`;
+	return {
+		kind: "collation",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		...text(row.collprovider) === void 0 ? {} : { provider: text(row.collprovider) },
+		...(text(row.colliculocale) ?? text(row.collcollate) ?? text(row.collctype)) === void 0 ? {} : { locale: text(row.colliculocale) ?? text(row.collcollate) ?? text(row.collctype) },
+		...row.collisdeterministic === void 0 || row.collisdeterministic === null ? {} : { deterministic: boolean(row.collisdeterministic) },
+		...text(row.collversion) === void 0 ? {} : { version: text(row.collversion) },
+		reference: reference("collation", physicalName, text(row.namespace) ?? namespace, "pg_collation", "oid", row.oid)
+	};
+}
+function triggerObject(row, namespace, relationReferences, diagnostics) {
+	const physicalName = text(row.physical_name) ?? `trigger_${text(row.oid) ?? "unknown"}`;
+	const physicalReference = reference("trigger", physicalName, text(row.namespace) ?? namespace, "pg_trigger", "oid", row.oid);
+	const table = relationReferences.get(text(row.table_oid));
+	const definition = text(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(row.table_oid) ?? "unknown"
+		}] : [], ...definition === void 0 ? [] : [{
+			name: "definition",
+			value: expression(definition, "decompiler", physicalReference)
+		}]]);
+	}
+	const triggerType = number(row.trigger_type) ?? 0;
+	const timing = triggerType & 64 ? "instead-of" : triggerType & 2 ? "before" : "after";
+	const events = triggerEvents(triggerType);
+	const mode = triggerType & 1 ? "row" : "statement";
+	const enabled = triggerEnabled(row.tgenabled);
+	return {
+		kind: "trigger",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		table,
+		timing,
+		events,
+		orientation: mode,
+		...text(row.condition) === void 0 ? {} : { condition: expression(text(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(row.routine_oid) ?? "unknown");
+	const names = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const name = text(row.physical_name) ?? `routine_${text(row.oid) ?? "unknown"}`;
+		names.set(name, (names.get(name) ?? 0) + 1);
+	}
+	return rows.map((row) => {
+		const physicalName = text(row.physical_name) ?? `routine_${text(row.oid) ?? "unknown"}`;
+		const physicalReference = reference("routine", physicalName, text(row.namespace) ?? namespace, "pg_proc", "oid", row.oid);
+		const identityArguments = text(row.identity_arguments);
+		const defaultArguments = text(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(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(row.oid)) ?? []).sort((left, right) => (number(left.ordinal_position) ?? 0) - (number(right.ordinal_position) ?? 0)).map((parameter) => ({
+			...text(parameter.parameter_name) === void 0 ? {} : { name: text(parameter.parameter_name) },
+			...routineParameterMode(parameter.mode) === void 0 ? {} : { mode: routineParameterMode(parameter.mode) },
+			storage: storage(parameter.native_type),
+			ordinalPosition: number(parameter.ordinal_position) ?? 0,
+			provenance: {
+				kind: "catalog",
+				dialect: "postgresql",
+				reference: physicalReference
+			}
+		}));
+		return {
+			kind: "routine",
+			id: stableId((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(row.return_type) === void 0 ? {} : { returnType: storage(row.return_type) },
+			...text(row.language) === void 0 ? {} : { language: text(row.language) },
+			...text(row.definition) === void 0 ? {} : { body: expression(text(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(row.prosecdef) ? "definer" : "invoker" },
+			...routineUnknownFields.length === 0 ? {} : { unknownFields: routineUnknownFields },
+			reference: physicalReference
+		};
+	});
+}
+function partitionObject(row, namespace, tableByOid, diagnostics) {
+	const physicalName = text(row.physical_name) ?? `partition_${text(row.partition_oid) ?? "unknown"}`;
+	const physicalReference = reference("partition", physicalName, text(row.namespace) ?? namespace, "pg_class", "oid", row.partition_oid);
+	if (!boolean(row.relispartition)) return inheritanceObject(row, namespace, diagnostics);
+	const parent = tableByOid.get(text(row.parent_oid));
+	const keyDefinition = text(row.key_definition);
+	const bound = text(row.bound);
+	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."
+		}));
+		return deferredCatalogObject("partition", physicalName, physicalReference, [
+			...text(row.parent_oid) === void 0 ? [] : [{
+				name: "parentOid",
+				value: text(row.parent_oid)
+			}],
+			...text(row.key_attributes) === void 0 ? [] : [{
+				name: "keyAttributes",
+				value: text(row.key_attributes)
+			}],
+			...keyDefinition === void 0 ? [] : [{
+				name: "keyDefinition",
+				value: expression(keyDefinition, "decompiler", physicalReference)
+			}],
+			...bound === void 0 ? [] : [{
+				name: "bound",
+				value: expression(bound, "decompiler", physicalReference)
+			}]
+		]);
+	}
+	const keyInfo = partitionKeyInfo(row.key_attributes, parent.columns);
+	const unknownFields = [];
+	if (keyDefinition !== void 0 && (keyInfo.hasExpression || keyInfo.missingPositions.length > 0 || keyInfo.columns.length === 0)) unknownFields.push({
+		name: "keyDefinition",
+		value: expression(keyDefinition, "decompiler", physicalReference)
+	});
+	if (keyInfo.missingPositions.length > 0 || keyInfo.hasExpression && keyDefinition === void 0) {
+		const keyAttributes = text(row.key_attributes);
+		if (keyAttributes !== void 0) unknownFields.push({
+			name: "keyAttributes",
+			value: keyAttributes
+		});
+	}
+	if (keyInfo.hasExpression) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "unsupported-feature",
+		message: `PostgreSQL partition ${physicalName} has an expression key retained as dialect evidence`,
+		path: [
+			"partitions",
+			physicalName,
+			"keyDefinition"
+		],
+		physicalReference,
+		remediation: "Inspect the retained partition key definition before using it as migration input."
+	}));
+	if (keyInfo.missingPositions.length > 0) diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "unresolved-reference",
+		message: `PostgreSQL partition ${physicalName} has unknown key attributes`,
+		path: [
+			"partitions",
+			physicalName,
+			"keyAttributes"
+		],
+		physicalReference
+	}));
+	return {
+		kind: "partition",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		parent: {
+			kind: "table",
+			id: parent.id
+		},
+		strategy: partitionStrategy(row.partstrat),
+		...keyInfo.hasExpression || keyInfo.missingPositions.length > 0 || keyInfo.columns.length === 0 ? {} : { keyColumns: keyInfo.columns },
+		...bound === void 0 ? {} : { bound: expression(bound, "decompiler", physicalReference) },
+		...bound !== void 0 && /^default$/i.test(bound.trim()) ? { default: true } : {},
+		...unknownFields.length === 0 ? {} : { unknownFields },
+		reference: physicalReference
+	};
+}
+function inheritanceObject(row, namespace, diagnostics) {
+	const physicalName = text(row.physical_name) ?? `inherited_${text(row.partition_oid) ?? "unknown"}`;
+	const physicalReference = reference("opaque-object", physicalName, text(row.namespace) ?? namespace, "pg_inherits", "inhrelid", row.partition_oid);
+	diagnostics.push(createIntrospectionDiagnostic({
+		severity: "warning",
+		code: "unmodeled-object",
+		message: `PostgreSQL ordinary inheritance ${physicalName} was retained as opaque evidence`,
+		path: ["opaqueObjects", physicalName],
+		physicalReference,
+		remediation: "Inspect the inheritance relationship before using it as migration input."
+	}));
+	return {
+		kind: "opaque-object",
+		id: stableId(`inheritance:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: "ordinary-inheritance",
+		physicalName,
+		data: {
+			...text(row.parent_oid) === void 0 ? {} : { parentOid: text(row.parent_oid) },
+			...text(row.relkind) === void 0 ? {} : { childRelkind: text(row.relkind) },
+			relispartition: false
+		},
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "postgresql",
+			reference: physicalReference
+		}
+	};
+}
+function partitionKeyInfo(value, columns) {
+	const attributes = integerArray(value);
+	const byOrdinal = new Map(columns.map((column) => [column.ordinalPosition, column.physicalName]));
+	const positions = attributes.filter((position) => position > 0);
+	const missingPositions = positions.filter((position) => !byOrdinal.has(position));
+	return {
+		columns: positions.flatMap((position) => {
+			const name = byOrdinal.get(position);
+			return name === void 0 ? [] : [name];
+		}),
+		hasExpression: attributes.some((position) => position === 0),
+		missingPositions
+	};
+}
+function policyObject(row, namespace, tableByOid, diagnostics) {
+	const physicalName = text(row.physical_name) ?? `policy_${text(row.oid) ?? "unknown"}`;
+	const physicalReference = reference("policy", physicalName, text(row.namespace) ?? namespace, "pg_policy", "oid", row.oid);
+	const table = tableByOid.get(text(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(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		table: table ? {
+			kind: "table",
+			id: table.id
+		} : {
+			kind: "table",
+			id: stableId(`missing_table_${text(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(row.polpermissive) },
+		...text(row.using_expression) === void 0 ? {} : { using: expression(text(row.using_expression), "decompiler", physicalReference) },
+		...text(row.check_expression) === void 0 ? {} : { check: expression(text(row.check_expression), "decompiler", physicalReference) },
+		reference: physicalReference
+	};
+}
+function extensionObject(row, namespace) {
+	const physicalName = text(row.physical_name) ?? `extension_${text(row.oid) ?? "unknown"}`;
+	const physicalReference = reference("extension", physicalName, text(row.namespace) ?? namespace, "pg_extension", "oid", row.oid);
+	const data = { relocatable: boolean(row.extrelocatable) };
+	const configuration = {};
+	if (text(row.config_relations) !== void 0) configuration.relations = text(row.config_relations);
+	if (text(row.config_conditions) !== void 0) configuration.conditions = text(row.config_conditions);
+	return {
+		kind: "extension",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		extensionName: physicalName,
+		...text(row.extversion) === void 0 ? {} : { extensionVersion: text(row.extversion) },
+		...text(row.namespace) === void 0 ? {} : { schema: text(row.namespace) },
+		data,
+		...Object.keys(configuration).length === 0 ? {} : { configuration },
+		dialect: {
+			dialect: "postgresql",
+			version: 1,
+			data: { relocatable: boolean(row.extrelocatable) }
+		},
+		reference: physicalReference
+	};
+}
+function deferredCatalogObject(objectKind, physicalName, physicalReference, unknownFields = []) {
+	return {
+		kind: "deferred-object",
+		objectKind,
+		id: stableId(`deferred_${objectKind}_${physicalName}`),
+		identitySource: "physical-name",
+		physicalName,
+		reference: physicalReference,
+		...unknownFields.length === 0 ? {} : { unknownFields }
+	};
+}
+function triggerEvents(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(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(value)] ?? "unknown";
+}
+function routineParameterMode(value) {
+	return {
+		i: "in",
+		o: "out",
+		b: "inout",
+		v: "variadic",
+		t: "table"
+	}[text(value)];
+}
+function routineVolatility(value) {
+	return {
+		i: "immutable",
+		s: "stable",
+		v: "volatile"
+	}[text(value)];
+}
+function routineParallel(value) {
+	return {
+		s: "safe",
+		r: "restricted",
+		u: "unsafe"
+	}[text(value)];
+}
+function partitionStrategy(value) {
+	return {
+		r: "range",
+		l: "list",
+		h: "hash"
+	}[text(value)] ?? "unknown";
+}
+function policyCommand(value) {
+	return {
+		"*": "all",
+		r: "select",
+		a: "insert",
+		w: "update",
+		d: "delete"
+	}[text(value)] ?? "unknown";
+}
+function storage(value) {
+	return { nativeType: text(value) ?? "unknown" };
+}
+function factIfPresent(value) {
+	if (value === void 0 || value === null) return;
+	return literalFact(value);
+}
+function literalFact(value) {
+	if (value === void 0) return;
+	if (value === null) return {
+		kind: "literal",
+		value: null
+	};
+	if (typeof value === "boolean") return {
+		kind: "literal",
+		value
+	};
+	if (typeof value === "bigint") return {
+		kind: "literal",
+		value
+	};
+	if (typeof value === "number") return Number.isFinite(value) ? {
+		kind: "literal",
+		value
+	} : {
+		kind: "literal",
+		value: String(value)
+	};
+	const textValue = String(value);
+	if (/^[+-]?\d+$/.test(textValue.trim())) try {
+		const integerValue = BigInt(textValue);
+		if (integerValue > BigInt(Number.MAX_SAFE_INTEGER) || integerValue < BigInt(Number.MIN_SAFE_INTEGER)) return {
+			kind: "literal",
+			value: integerValue
+		};
+	} catch {}
+	const numericValue = Number(textValue);
+	return textValue.trim() !== "" && Number.isFinite(numericValue) ? {
+		kind: "literal",
+		value: numericValue
+	} : {
+		kind: "literal",
+		value: textValue
+	};
+}
+function relationTable(row) {
+	const physicalName = text(row.relname) ?? "unnamed_table";
+	return {
+		kind: "table",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		reference: reference("table", physicalName, text(row.namespace), "pg_class", "oid", row.oid),
+		columns: [],
+		constraints: [],
+		indexes: [],
+		unknownFields: boolean(row.relispartition) ? [{
+			name: "partitioned",
+			value: true
+		}] : void 0
+	};
+}
+function deferredObject(row, objectKind = "other") {
+	const physicalName = text(row.relname) ?? "unnamed_object";
+	return {
+		kind: "deferred-object",
+		objectKind,
+		id: stableId(`deferred:${objectKind}:${physicalName}`),
+		identitySource: "physical-name",
+		physicalName,
+		reference: reference("deferred-object", physicalName, text(row.namespace), "pg_class", "oid", row.oid)
+	};
+}
+function opaqueRelationObject(row, namespace, diagnostics) {
+	const physicalName = text(row.relname) ?? "unnamed_object";
+	const relkind = text(row.relkind) ?? "unknown";
+	const physicalReference = reference("opaque-object", physicalName, text(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(`relation:${relkind}:${physicalName}`),
+		identitySource: "physical-name",
+		physicalName,
+		objectKind: `postgres-relation:${relkind}`,
+		data: {
+			relkind,
+			relispartition: boolean(row.relispartition)
+		},
+		reference: physicalReference
+	};
+}
+function column(row, table, namespace, identityOptionValues) {
+	const physicalName = text(row.physical_name) ?? "unnamed_column";
+	const defaultExpression = text(row.default_expression);
+	const identityValue = text(row.attidentity);
+	const generatedValue = text(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(defaultExpression, namespace, table, physicalName)
+	} : void 0;
+	const ordinaryDefault = defaultExpression && !identity && !generated ? {
+		kind: "expression",
+		expression: sql(defaultExpression, namespace, table, physicalName)
+	} : void 0;
+	return {
+		kind: "column",
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		ordinalPosition: number(row.ordinal_position) ?? 0,
+		nullable: boolean(row.nullable),
+		storage: { nativeType: text(row.native_type) ?? "unknown" },
+		...ordinaryDefault ? { default: ordinaryDefault } : {},
+		...generated ? { generated } : {},
+		identity,
+		reference: reference("column", physicalName, namespace, "pg_attribute", "attrelid", row.table_oid)
+	};
+}
+function constraint(row, table, columnsByNumber, tableByOid, namespace, diagnostics, indexReferences) {
+	const kind = text(row.contype);
+	const physicalName = text(row.physical_name) ?? `constraint_${text(row.oid) ?? "unknown"}`;
+	const definition = text(row.definition);
+	const columns = integerArray(row.conkey).map((numberValue) => columnsByNumber.get(numberValue) ?? `attnum_${numberValue}`);
+	const common = {
+		id: stableId(physicalName),
+		identitySource: "physical-name",
+		physicalName,
+		deferrable: boolean(row.condeferrable),
+		initially: boolean(row.condeferred) ? "deferred" : "immediate",
+		validated: boolean(row.convalidated),
+		reference: reference("constraint", physicalName, namespace, "pg_constraint", "oid", row.oid),
+		dialect: row.convalidated === false ? {
+			dialect: "postgresql",
+			version: 1,
+			data: { notValid: true }
+		} : void 0
+	};
+	const backingOid = text(row.backing_index_oid);
+	const backing = backingOid ? indexReferences.get(`pg_class:${backingOid}`) : void 0;
+	const backingIndex = backing ? {
+		kind: "index",
+		id: backing.id,
+		owner: {
+			kind: "table",
+			id: table.id
+		}
+	} : void 0;
+	if (kind === "x" || kind === "c" && (definition === void 0 || definition.trim() === "")) {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "warning",
+			code: "unmodeled-object",
+			message: kind === "x" ? `PostgreSQL exclusion constraint ${physicalName} was retained as opaque evidence` : `PostgreSQL check constraint ${physicalName} has no recoverable definition`,
+			path: [
+				"tables",
+				table.physicalName,
+				"constraints",
+				physicalName
+			],
+			physicalReference: reference("opaque-object", physicalName, namespace, "pg_constraint", "oid", row.oid),
+			remediation: "Inspect the opaque constraint before using it as migration input."
+		}));
+		return opaqueConstraint(row, table, namespace, definition);
+	}
+	if (kind === "p") return {
+		kind: "primary-key",
+		...common,
+		columns,
+		...backingIndex === void 0 ? {} : { backingIndex }
+	};
+	if (kind === "u") return {
+		kind: "unique",
+		...common,
+		columns,
+		nulls: boolean(row.indnullsnotdistinct) ? "not-distinct" : "distinct",
+		...backingIndex === void 0 ? {} : { backingIndex }
+	};
+	if (kind === "c") return {
+		kind: "check",
+		...common,
+		expression: sql(definition, namespace, table, physicalName)
+	};
+	if (kind !== "f") {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "warning",
+			code: "unmodeled-object",
+			message: `PostgreSQL constraint ${physicalName} (${kind ?? "unknown"}) was retained as opaque evidence`,
+			path: [
+				"tables",
+				table.physicalName,
+				"constraints",
+				physicalName
+			],
+			remediation: "Inspect the opaque constraint before using it as migration input."
+		}));
+		return opaqueConstraint(row, table, namespace, definition);
+	}
+	const targetTable = tableByOid.get(text(row.target_table_oid));
+	if (!targetTable) {
+		diagnostics.push(createIntrospectionDiagnostic({
+			severity: "error",
+			code: "unresolved-reference",
+			message: `PostgreSQL foreign key target ${text(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 opaqueConstraint(row, table, namespace, definition) {
+	const physicalName = text(row.physical_name) ?? `constraint_${text(row.oid) ?? "unknown"}`;
+	const physicalReference = reference("opaque-object", physicalName, namespace, "pg_constraint", "oid", row.oid);
+	const data = {
+		table: table.physicalName,
+		constraintType: text(row.contype) ?? "unknown",
+		...text(row.conkey) === void 0 ? {} : { keyAttributes: text(row.conkey) },
+		...text(row.backing_index_oid) === void 0 ? {} : { backingIndexOid: text(row.backing_index_oid) }
+	};
+	return {
+		kind: "opaque-object",
+		id: stableId(`constraint:${table.physicalName}:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: text(row.contype) === "x" ? "exclusion-constraint" : "constraint",
+		physicalName,
+		data,
+		...definition === void 0 ? {} : { sql: sql(definition, namespace, table, physicalName) },
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "postgresql",
+			reference: physicalReference
+		}
+	};
+}
+function mapIndexes(rows, table, columnsByNumber, namespace, diagnostics, opaqueObjects) {
+	const grouped = /* @__PURE__ */ new Map();
+	for (const row of rows) {
+		const key = text(row.index_oid) ?? text(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(left.position) ?? 0) - (number(right.position) ?? 0));
+		const first = orderedRows[0];
+		const physicalName = text(first.physical_name) ?? `index_${text(first.index_oid) ?? "unknown"}`;
+		const keyCount = number(first.indnkeyatts) ?? indexRows.length;
+		const terms = [];
+		const includedColumns = [];
+		let unavailableTerm = false;
+		for (const row of orderedRows) {
+			const position = number(row.position) ?? 0;
+			const attnum = number(row.attnum) ?? 0;
+			const columnName = attnum > 0 ? columnsByNumber.get(attnum) : void 0;
+			if (position > keyCount) {
+				if (columnName) includedColumns.push(columnName);
+				continue;
+			}
+			const termDefinition = text(row.term_definition);
+			if (!columnName && (termDefinition === void 0 || termDefinition.trim() === "")) {
+				unavailableTerm = true;
+				diagnostics.push(createIntrospectionDiagnostic({
+					severity: "warning",
+					code: "unmodeled-object",
+					message: `PostgreSQL index ${physicalName} has an expression term with no recoverable definition`,
+					path: [
+						table.physicalName,
+						"indexes",
+						physicalName,
+						"terms",
+						position
+					],
+					physicalReference: reference("index", physicalName, namespace, "pg_class", "oid", first.index_oid),
+					remediation: "Inspect the opaque index record before using it as migration input."
+				}));
+				continue;
+			}
+			terms.push(columnName ? {
+				kind: "column",
+				column: columnName,
+				position,
+				...indexTermOptions(row, text(first.method)),
+				...text(row.operator_class) === void 0 ? {} : { operatorClass: text(row.operator_class) }
+			} : {
+				kind: "expression",
+				expression: sql(termDefinition, namespace, table, physicalName),
+				position,
+				...indexTermOptions(row, text(first.method)),
+				...text(row.operator_class) === void 0 ? {} : { operatorClass: text(row.operator_class) }
+			});
+		}
+		if (unavailableTerm) {
+			opaqueObjects.push(opaqueIndex(indexRows, table, namespace));
+			return;
+		}
+		return {
+			kind: "index",
+			id: stableId(physicalName),
+			identitySource: "physical-name",
+			physicalName,
+			unique: boolean(first.indisunique),
+			terms,
+			predicate: text(first.predicate) ? sql(text(first.predicate), namespace, table, physicalName) : void 0,
+			includedColumns: includedColumns.length > 0 ? includedColumns : void 0,
+			method: text(first.method),
+			dialect: text(first.method) && text(first.method) !== "btree" ? {
+				dialect: "postgresql",
+				version: 1,
+				data: { method: text(first.method) }
+			} : void 0,
+			reference: reference("index", physicalName, namespace, "pg_class", "oid", first.index_oid)
+		};
+	}).filter((value) => value !== void 0);
+}
+function opaqueIndex(rows, table, namespace) {
+	const first = rows[0];
+	const physicalName = text(first.physical_name) ?? `index_${text(first.index_oid) ?? "unknown"}`;
+	const physicalReference = reference("opaque-object", physicalName, namespace, "pg_class", "oid", first.index_oid);
+	return {
+		kind: "opaque-object",
+		id: stableId(`index:${table.physicalName}:${physicalName}`),
+		identitySource: "physical-name",
+		objectKind: "index",
+		physicalName,
+		data: {
+			table: table.physicalName,
+			reason: "term-definition-unavailable",
+			...text(first.index_oid) === void 0 ? {} : { indexOid: text(first.index_oid) }
+		},
+		reference: physicalReference,
+		provenance: {
+			kind: "catalog",
+			dialect: "postgresql",
+			reference: physicalReference
+		}
+	};
+}
+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(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.owner === void 0 ? {} : { owner: index.owner }
+	}, 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,
+			owner: {
+				kind: "table",
+				id: table.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,
+			owner: {
+				kind: "domain",
+				id: domain.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(row.catalog_relation) ?? "unknown";
+		const oid = text(row.object_oid);
+		const subid = number(row.object_subid) ?? 0;
+		const target = targets.get(metadataKey(relation, oid, subid));
+		if (target === void 0) {
+			const unknownReference = reference("opaque-object", text(row.object_name) ?? `metadata_${oid ?? "unknown"}`, text(row.namespace) ?? namespace, relation, "oid", oid);
+			diagnostics.push(createIntrospectionDiagnostic({
+				severity: "warning",
+				code: "unmodeled-object",
+				message: `PostgreSQL metadata row for ${text(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(`metadata_${relation}_${oid ?? "unknown"}_${subid}`),
+				identitySource: "physical-name",
+				physicalName: text(row.object_name) ?? `metadata_${oid ?? "unknown"}`,
+				objectKind: `postgres-metadata:${text(row.object_kind) ?? "unknown"}`,
+				data: {
+					catalogRelation: relation,
+					objectOid: oid ?? "unknown",
+					objectSubid: subid,
+					...text(row.description) === void 0 ? {} : { description: text(row.description) },
+					...text(row.owner) === void 0 ? {} : { owner: text(row.owner) }
+				},
+				reference: unknownReference
+			});
+			continue;
+		}
+		const description = text(row.description);
+		if (description !== void 0) comments.push({
+			kind: "comment",
+			id: metadataId(target.object, "comment"),
+			object: target.object,
+			text: description,
+			reference: target.reference,
+			provenance: {
+				kind: "catalog",
+				dialect: "postgresql",
+				reference: target.reference
+			}
+		});
+		const owner = text(row.owner);
+		if (owner !== void 0) ownership.push({
+			kind: "ownership",
+			id: metadataId(target.object, "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,
+			owner: {
+				kind: owner.kind,
+				id: owner.id
+			}
+		},
+		reference: column.reference ?? reference("column", column.physicalName, namespace, "pg_attribute", "attrelid", tableOid),
+		physicalName: column.physicalName
+	});
+}
+function metadataKey(relation, oid, subid) {
+	return `${relation}:${text(oid) ?? "unknown"}:${number(subid) ?? 0}`;
+}
+function metadataId(object, suffix) {
+	const owner = object.owner;
+	return stableId(`${owner === void 0 ? "" : `${owner.kind}_${owner.id}_`}${object.kind}_${object.id}_${suffix}`);
+}
+function indexTermOptions(row, method) {
+	const option = number(row.indoption);
+	if (method !== "btree" || option === void 0) return {};
+	return {
+		direction: option & 1 ? "DESC" : "ASC",
+		nulls: option & 2 ? "FIRST" : "LAST"
+	};
+}
+function sql(textValue, namespace, owner, name) {
+	return expression(textValue, "decompiler", owner.reference ?? reference("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(kind, name, namespace, relation, key, value = name) {
+	return {
+		kind,
+		name,
+		namespace,
+		catalog: {
+			relation,
+			key,
+			value: typeof value === "number" ? value : String(value)
+		}
+	};
+}
+function stableId(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(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 parsed = Number(value);
+		return Number.isFinite(parsed) ? parsed : void 0;
+	}
+}
+function boolean(value) {
+	return value === true || value === "t" || value === "true" || value === 1;
+}
+function stringArray(value) {
+	if (Array.isArray(value)) return value.map((item) => text(item)).filter((item) => item !== void 0);
+	const source = text(value)?.trim();
+	if (source === void 0 || source === "") return [];
+	if (source.startsWith("{") && source.endsWith("}")) {
+		const values = [];
+		let current = "";
+		let quoted = false;
+		let escaped = false;
+		for (const character of source.slice(1, -1)) if (escaped) {
+			current += character;
+			escaped = false;
+		} else if (character === "\\" && quoted) escaped = true;
+		else if (character === "\"") quoted = !quoted;
+		else if (character === "," && !quoted) {
+			values.push(current);
+			current = "";
+		} else current += character;
+		if (current !== "" || source !== "{}") values.push(current);
+		return values.filter((value) => value !== "");
+	}
+	return source.split(",").map((item) => item.trim()).filter((item) => item !== "");
+}
+function booleanOption(options, name) {
+	const value = options.find((option) => option.startsWith(`${name}=`));
+	if (value === void 0) return;
+	const setting = value.slice(name.length + 1).toLowerCase();
+	if (setting === "true" || setting === "on" || setting === "yes") return true;
+	if (setting === "false" || setting === "off" || setting === "no") return false;
+}
+function integerArray(value) {
+	if (Array.isArray(value)) return value.map((item) => number(item) ?? 0);
+	const parsed = text(value)?.replace(/^\[[^\]]+\]=/, "").replace(/[{}]/g, "").trim();
+	if (!parsed) return [];
+	return parsed.split(/[\s,]+/).map((item) => number(item.trim())).filter((item) => item !== void 0);
+}
+function referentialAction(value) {
+	return {
+		a: "no-action",
+		r: "restrict",
+		c: "cascade",
+		n: "set-null",
+		d: "set-default"
+	}[text(value)];
+}
+function matchType(value) {
+	return {
+		s: "simple",
+		f: "full",
+		p: "partial"
+	}[text(value)];
+}
+//#endregion
+export { postgresCollationsQuery, postgresColumnsQuery, postgresConstraintsQuery, postgresConstraintsQueryWithoutNullsNotDistinct, postgresDomainConstraintsQuery, postgresDomainsQuery, postgresEnumsQuery, postgresExtensionsQuery, postgresIdentitiesQuery, postgresIndexesQuery, postgresMetadataQuery, postgresPartitionsQuery, postgresPoliciesQuery, postgresRelationsQuery, postgresRoutineParametersQuery, postgresRoutinesQuery, postgresSequencesQuery, postgresServerQuery, postgresTriggersQuery, postgresViewsQuery, readCatalog };