neon 3.0.0 → 3.1.1

package/dist/psql/command/cmd_describe.js

@@ -1,1815 +1,1626 @@
-/**
- * psql `\d*` describe-command dispatchers.
- *
- * Each command takes an optional pattern, parses verbose / show-system
- * suffixes from the command name, runs the appropriate SQL template
- * from {@link '../describe/queries.js'} through the pattern parser, and
- * prints the result via the aligned printer.
- *
- * Command name suffix decoding:
- *
- *  - Trailing `+` → `verbose=true` (extra columns)
- *  - Trailing `S` → `showSystem=true` (include `pg_*` schemas)
- *  - Both may combine: `\dtS+`, `\dt+S`, etc.
- *
- * Dispatch model: every `\d*` family registers itself as a separate
- * primary name (e.g. `dt`, `dt+`, `dtS`, `dtS+`). That's not how psql
- * itself does it — psql parses a single `\d` token and then peels off
- * letter-by-letter — but our `BackslashRegistry` is keyed by full
- * command name and is much easier to read this way. The semantic
- * outcome is identical.
- *
- * For `\d <name>` (the bare describe), we look the relation up via
- * {@link lookupOneRelation} and dispatch to the right `describeOne*`
- * renderer based on relkind:
- *
- *  - 'r' / 'p' / 'f' (regular, partitioned, foreign) →
- *    {@link describeOneTableDetails}
- *  - 'v' → {@link describeOneViewDetails}
- *  - 'S' → {@link describeOneSequence}
- *  - 'i' / 'I' (index, partitioned index) → table-detail with index header
- *  - 'm' → table-detail with materialized-view header
- *
- * Connection guard: every command checks `ctx.settings.db` is non-null
- * and emits `\<cmd>: no current connection` to stderr on miss.
- */
-import { describeOneSequence, describeOneTableDetails, describeOneViewDetails, lookupOneRelation, runListQuery, } from "../describe/formatters.js";
-import { processSQLNamePattern, } from "../describe/processNamePattern.js";
-import { describeAccessMethods, describeAggregates, describeConfigurationParameters, describeFunctions, describeOperators, describeRoleGrants, describeRoles, describeSubscriptions, describeTableDetails, describeTablespaces, describeTypes, listAllDbs, listCasts, listCollations, listConversions, listDbRoleSettings, listDefaultACLs, listDomains, listEventTriggers, listExtendedStats, listExtensions, listForeignDataWrappers, listForeignServers, listForeignTables, listLanguages, listLargeObjects, listOperatorClasses, listOperatorFamilies, listOpFamilyFunctions, listOpFamilyOperators, listPartitionedTables, listPublications, listSchemas, listTables, listTSConfigs, listTSDictionaries, listTSParsers, listTSTemplates, listUserMappings, objectDescription, permissionsList, } from "../describe/queries.js";
 import { writeErr } from "./shared.js";
+import { processSQLNamePattern } from "../describe/processNamePattern.js";
+import { describeAccessMethods, describeAggregates, describeConfigurationParameters, describeFunctions, describeOperators, describeRoleGrants, describeRoles, describeSubscriptions, describeTableDetails, describeTablespaces, describeTypes, listAllDbs, listCasts, listCollations, listConversions, listDbRoleSettings, listDefaultACLs, listDomains, listEventTriggers, listExtendedStats, listExtensions, listForeignDataWrappers, listForeignServers, listForeignTables, listLanguages, listLargeObjects, listOpFamilyFunctions, listOpFamilyOperators, listOperatorClasses, listOperatorFamilies, listPartitionedTables, listPublications, listSchemas, listTSConfigs, listTSDictionaries, listTSParsers, listTSTemplates, listTables, listUserMappings, objectDescription, permissionsList } from "../describe/queries.js";
+import { describeOneSequence, describeOneTableDetails, describeOneViewDetails, lookupOneRelation, runListQuery } from "../describe/formatters.js";
+//#region src/psql/command/cmd_describe.ts
+/**
+* psql `\d*` describe-command dispatchers.
+*
+* Each command takes an optional pattern, parses verbose / show-system
+* suffixes from the command name, runs the appropriate SQL template
+* from {@link '../describe/queries.js'} through the pattern parser, and
+* prints the result via the aligned printer.
+*
+* Command name suffix decoding:
+*
+*  - Trailing `+` → `verbose=true` (extra columns)
+*  - Trailing `S` → `showSystem=true` (include `pg_*` schemas)
+*  - Both may combine: `\dtS+`, `\dt+S`, etc.
+*
+* Dispatch model: every `\d*` family registers itself as a separate
+* primary name (e.g. `dt`, `dt+`, `dtS`, `dtS+`). That's not how psql
+* itself does it — psql parses a single `\d` token and then peels off
+* letter-by-letter — but our `BackslashRegistry` is keyed by full
+* command name and is much easier to read this way. The semantic
+* outcome is identical.
+*
+* For `\d <name>` (the bare describe), we look the relation up via
+* {@link lookupOneRelation} and dispatch to the right `describeOne*`
+* renderer based on relkind:
+*
+*  - 'r' / 'p' / 'f' (regular, partitioned, foreign) →
+*    {@link describeOneTableDetails}
+*  - 'v' → {@link describeOneViewDetails}
+*  - 'S' → {@link describeOneSequence}
+*  - 'i' / 'I' (index, partitioned index) → table-detail with index header
+*  - 'm' → table-detail with materialized-view header
+*
+* Connection guard: every command checks `ctx.settings.db` is non-null
+* and emits `\<cmd>: no current connection` to stderr on miss.
+*/
 /**
- * Helper: split a `\dXY+` command name into base, verbose, showSystem.
- *
- *   "dtS+"  → { base: "dt", verbose: true, showSystem: true }
- *   "df+"   → { base: "df", verbose: true, showSystem: false }
- *   "dnS"   → { base: "dn", verbose: false, showSystem: true }
- */
+* Helper: split a `\dXY+` command name into base, verbose, showSystem.
+*
+*   "dtS+"  → { base: "dt", verbose: true, showSystem: true }
+*   "df+"   → { base: "df", verbose: true, showSystem: false }
+*   "dnS"   → { base: "dn", verbose: false, showSystem: true }
+*/
 const decodeSuffix = (cmdName, base) => {
-    const tail = cmdName.slice(base.length);
-    let verbose = false;
-    let showSystem = false;
-    // Suffix order is unrestricted in psql.
-    for (const ch of tail) {
-        if (ch === "+")
-            verbose = true;
-        else if (ch === "S")
-            showSystem = true;
-    }
-    return { verbose, showSystem };
+	const tail = cmdName.slice(base.length);
+	let verbose = false;
+	let showSystem = false;
+	for (const ch of tail) if (ch === "+") verbose = true;
+	else if (ch === "S") showSystem = true;
+	return {
+		verbose,
+		showSystem
+	};
 };
 /** Resolve the current connection or null. */
 const conn = (ctx) => ctx.settings.db;
 /** Emit "no current connection" error. */
 const noConn = (ctx) => {
-    writeErr(`\\${ctx.cmdName}: no current connection\n`);
-    return { status: "error", errorWritten: true };
+	writeErr(`\\${ctx.cmdName}: no current connection\n`);
+	return {
+		status: "error",
+		errorWritten: true
+	};
 };
 /**
- * Read the connection's current database. Mirrors upstream's
- * `PQdb(pset.db)` — used by the cross-database check. PgConnection
- * exposes `database` as a getter; mocks typically pass it as a record
- * property. Returns `''` on miss; callers compare case-sensitively
- * (matching upstream's `strcmp`).
- */
+* Read the connection's current database. Mirrors upstream's
+* `PQdb(pset.db)` — used by the cross-database check. PgConnection
+* exposes `database` as a getter; mocks typically pass it as a record
+* property. Returns `''` on miss; callers compare case-sensitively
+* (matching upstream's `strcmp`).
+*/
 const currentDb = (c) => {
-    const meta = c;
-    return typeof meta.database === "string" ? meta.database : "";
+	const meta = c;
+	return typeof meta.database === "string" ? meta.database : "";
 };
 /**
- * Validate a `processSQLNamePattern` result against the command's max
- * dotted-name budget. Mirrors the dot-count check upstream's
- * `processSQLNamePattern` performs after parsing:
- *
- *  - `dotCount > maxDots` → "improper qualified name (too many dotted names)"
- *  - `dotCount == 2 && maxDots == 2 && dbLiteral != current_db` →
- *    "cross-database references are not implemented"
- *
- * Pass `maxDots = 0` for commands that don't accept schema-qualified
- * patterns (`\dA`, `\dx`, `\dn`, `\db`, `\des`, …). Pass `maxDots = 2`
- * for the schema-qualified-with-db family (`\dt`, `\df`, `\dD`, …) so
- * the 2-dot case emits the dedicated cross-database error rather than
- * a generic "too many" message.
- *
- * Returns `null` on success; the formatted error string otherwise.
- */
+* Validate a `processSQLNamePattern` result against the command's max
+* dotted-name budget. Mirrors the dot-count check upstream's
+* `processSQLNamePattern` performs after parsing:
+*
+*  - `dotCount > maxDots` → "improper qualified name (too many dotted names)"
+*  - `dotCount == 2 && maxDots == 2 && dbLiteral != current_db` →
+*    "cross-database references are not implemented"
+*
+* Pass `maxDots = 0` for commands that don't accept schema-qualified
+* patterns (`\dA`, `\dx`, `\dn`, `\db`, `\des`, …). Pass `maxDots = 2`
+* for the schema-qualified-with-db family (`\dt`, `\df`, `\dD`, …) so
+* the 2-dot case emits the dedicated cross-database error rather than
+* a generic "too many" message.
+*
+* Returns `null` on success; the formatted error string otherwise.
+*/
 const validatePattern = (pattern, result, maxDots, curDb) => {
-    if (pattern === null)
-        return null;
-    if (result.dotCount > maxDots) {
-        return `improper qualified name (too many dotted names): ${pattern}`;
-    }
-    if (maxDots >= 1 &&
-        result.dotCount === maxDots &&
-        result.dbLiteral !== null &&
-        result.dbLiteral !== curDb) {
-        return `cross-database references are not implemented: ${pattern}`;
-    }
-    return null;
+	if (pattern === null) return null;
+	if (result.dotCount > maxDots) return `improper qualified name (too many dotted names): ${pattern}`;
+	if (maxDots >= 1 && result.dotCount === maxDots && result.dbLiteral !== null && result.dbLiteral !== curDb) return `cross-database references are not implemented: ${pattern}`;
+	return null;
 };
 const runWithPattern = async (ctx, pattern, query, patternOpts, maxDots = 2, overrides = {}) => {
-    const c = conn(ctx);
-    if (!c)
-        return noConn(ctx);
-    const result = processSQLNamePattern({ ...patternOpts, pattern });
-    const dotErr = validatePattern(pattern, result, maxDots, currentDb(c));
-    if (dotErr !== null) {
-        writeErr(`${dotErr}\n`);
-        return { status: "error", errorWritten: true };
-    }
-    try {
-        const basePopt = ctx.settings.popt;
-        const popt = overrides.suppressDefaultFooter
-            ? { ...basePopt, topt: { ...basePopt.topt, defaultFooter: false } }
-            : basePopt;
-        await runListQuery(c, query, result, process.stdout, popt);
-        return { status: "ok" };
-    }
-    catch (err) {
-        writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
-        return { status: "error", errorWritten: true };
-    }
+	const c = conn(ctx);
+	if (!c) return noConn(ctx);
+	const result = processSQLNamePattern({
+		...patternOpts,
+		pattern
+	});
+	const dotErr = validatePattern(pattern, result, maxDots, currentDb(c));
+	if (dotErr !== null) {
+		writeErr(`${dotErr}\n`);
+		return {
+			status: "error",
+			errorWritten: true
+		};
+	}
+	try {
+		const basePopt = ctx.settings.popt;
+		const popt = overrides.suppressDefaultFooter ? {
+			...basePopt,
+			topt: {
+				...basePopt.topt,
+				defaultFooter: false
+			}
+		} : basePopt;
+		await runListQuery(c, query, result, process.stdout, popt);
+		return { status: "ok" };
+	} catch (err) {
+		writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
+		return {
+			status: "error",
+			errorWritten: true
+		};
+	}
 };
 /**
- * Apply two distinct {@link NamePatternResult}s to a query that emits two
- * placeholder occurrences (one per pattern). Mirrors `applyPattern` but
- * threads each result into a single occurrence so they can carry
- * different column targets (e.g. `\dAc <am> <type>` filters
- * `am.amname` first and `t.typname` second). When a slot's result
- * carries no conditions we substitute the `true` tautology so the
- * surrounding `AND`/`WHERE` chain stays well-formed.
- *
- * Returns a query string with the placeholders replaced and a unified
- * parameter list renumbered so `$N` references stay distinct.
- */
+* Apply two distinct {@link NamePatternResult}s to a query that emits two
+* placeholder occurrences (one per pattern). Mirrors `applyPattern` but
+* threads each result into a single occurrence so they can carry
+* different column targets (e.g. `\dAc <am> <type>` filters
+* `am.amname` first and `t.typname` second). When a slot's result
+* carries no conditions we substitute the `true` tautology so the
+* surrounding `AND`/`WHERE` chain stays well-formed.
+*
+* Returns a query string with the placeholders replaced and a unified
+* parameter list renumbered so `$N` references stay distinct.
+*/
 const applyTwoPatterns = (sql, baseParams, results) => {
-    const placeholder = "true /* TODO(WP-20): pattern matching */";
-    let rendered = sql;
-    const params = [...baseParams];
-    for (const result of results) {
-        const idx = rendered.indexOf(placeholder);
-        if (idx < 0)
-            break;
-        const conds = [
-            ...result.schemaConditions,
-            ...result.nameConditions,
-            ...result.visibilityConditions,
-        ];
-        const slotOffset = params.length;
-        const renumbered = conds.map((c) => c.replace(/\$(\d+)/g, (_, n) => `$${Number(n) + slotOffset}`));
-        params.push(...result.params);
-        const replacement = renumbered.length === 0 ? "true" : `(${renumbered.join(" AND ")})`;
-        rendered =
-            rendered.slice(0, idx) +
-                replacement +
-                rendered.slice(idx + placeholder.length);
-    }
-    return { sql: rendered, params };
+	const placeholder = "true /* TODO(WP-20): pattern matching */";
+	let rendered = sql;
+	const params = [...baseParams];
+	for (const result of results) {
+		const idx = rendered.indexOf(placeholder);
+		if (idx < 0) break;
+		const conds = [
+			...result.schemaConditions,
+			...result.nameConditions,
+			...result.visibilityConditions
+		];
+		const slotOffset = params.length;
+		const renumbered = conds.map((c) => c.replace(/\$(\d+)/g, (_, n) => `$${Number(n) + slotOffset}`));
+		params.push(...result.params);
+		const replacement = renumbered.length === 0 ? "true" : `(${renumbered.join(" AND ")})`;
+		rendered = rendered.slice(0, idx) + replacement + rendered.slice(idx + 40);
+	}
+	return {
+		sql: rendered,
+		params
+	};
 };
 /**
- * Run a list query with two distinct pattern slots. Builds the final
- * SQL via {@link applyTwoPatterns}, hands it to {@link runListQuery}
- * with an empty pattern result (so the second-pass `applyPattern` is a
- * no-op — all placeholders are already resolved).
- *
- * Note: we discard the query builder's `params` because the two-pattern
- * builders (`listOperatorClasses`, `listDbRoleSettings`) emit the raw
- * user strings there as a courtesy for single-pattern callers. The
- * regex-converted values come from `results[*].params` instead, so
- * threading the originals would introduce unreferenced bind values.
- */
+* Run a list query with two distinct pattern slots. Builds the final
+* SQL via {@link applyTwoPatterns}, hands it to {@link runListQuery}
+* with an empty pattern result (so the second-pass `applyPattern` is a
+* no-op — all placeholders are already resolved).
+*
+* Note: we discard the query builder's `params` because the two-pattern
+* builders (`listOperatorClasses`, `listDbRoleSettings`) emit the raw
+* user strings there as a courtesy for single-pattern callers. The
+* regex-converted values come from `results[*].params` instead, so
+* threading the originals would introduce unreferenced bind values.
+*/
 const runDualPatternList = async (ctx, query, results) => {
-    const c = conn(ctx);
-    if (!c)
-        return noConn(ctx);
-    const { sql, params } = applyTwoPatterns(query.sql, [], results);
-    const finalQuery = {
-        ...query,
-        sql,
-        params,
-    };
-    const empty = {
-        schemaConditions: [],
-        nameConditions: [],
-        visibilityConditions: [],
-        params: [],
-        dotCount: 0,
-        dbLiteral: null,
-    };
-    try {
-        await runListQuery(c, finalQuery, empty, process.stdout, ctx.settings.popt);
-        return { status: "ok" };
-    }
-    catch (err) {
-        writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
-        return { status: "error", errorWritten: true };
-    }
+	const c = conn(ctx);
+	if (!c) return noConn(ctx);
+	const { sql, params } = applyTwoPatterns(query.sql, [], results);
+	const finalQuery = {
+		...query,
+		sql,
+		params
+	};
+	const empty = {
+		schemaConditions: [],
+		nameConditions: [],
+		visibilityConditions: [],
+		params: [],
+		dotCount: 0,
+		dbLiteral: null
+	};
+	try {
+		await runListQuery(c, finalQuery, empty, process.stdout, ctx.settings.popt);
+		return { status: "ok" };
+	} catch (err) {
+		writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
+		return {
+			status: "error",
+			errorWritten: true
+		};
+	}
 };
 /**
- * Apply per-argument type patterns into the `ARG_PATTERN_<i>`
- * placeholders emitted by {@link describeFunctions} and
- * {@link describeOperators}. Each non-`-` arg pattern produces a set of
- * conditions against the `t<i>` / `nt<i>` join, matched against
- * `typname`, `nt<i>.nspname`, and the formatted-type expression — same
- * semantics as upstream's `validateSQLNamePattern(... ft, tiv, ...)`
- * call in `describe.c`. `-` slots emit a literal `typname IS NULL`
- * check at SQL build time and don't generate any conditions here.
- *
- * Returns the rewritten SQL plus the merged parameter list (renumbered
- * so `$N` slots from each arg pattern don't collide with prior slots).
- */
+* Apply per-argument type patterns into the `ARG_PATTERN_<i>`
+* placeholders emitted by {@link describeFunctions} and
+* {@link describeOperators}. Each non-`-` arg pattern produces a set of
+* conditions against the `t<i>` / `nt<i>` join, matched against
+* `typname`, `nt<i>.nspname`, and the formatted-type expression — same
+* semantics as upstream's `validateSQLNamePattern(... ft, tiv, ...)`
+* call in `describe.c`. `-` slots emit a literal `typname IS NULL`
+* check at SQL build time and don't generate any conditions here.
+*
+* Returns the rewritten SQL plus the merged parameter list (renumbered
+* so `$N` slots from each arg pattern don't collide with prior slots).
+*/
 const applyArgPatterns = (sql, baseParams, argResults) => {
-    let rendered = sql;
-    const params = [...baseParams];
-    for (let i = 0; i < argResults.length; i++) {
-        const placeholder = `true /* ARG_PATTERN_${i} */`;
-        const idx = rendered.indexOf(placeholder);
-        if (idx < 0)
-            continue;
-        const r = argResults[i];
-        let replacement = "true";
-        if (r !== null) {
-            const conds = [
-                ...r.schemaConditions,
-                ...r.nameConditions,
-                ...r.visibilityConditions,
-            ];
-            if (conds.length > 0) {
-                const slotOffset = params.length;
-                const renumbered = conds.map((c) => c.replace(/\$(\d+)/g, (_, n) => `$${Number(n) + slotOffset}`));
-                params.push(...r.params);
-                replacement = `(${renumbered.join(" AND ")})`;
-            }
-        }
-        rendered =
-            rendered.slice(0, idx) +
-                replacement +
-                rendered.slice(idx + placeholder.length);
-    }
-    return { sql: rendered, params };
+	let rendered = sql;
+	const params = [...baseParams];
+	for (let i = 0; i < argResults.length; i++) {
+		const placeholder = `true /* ARG_PATTERN_${i} */`;
+		const idx = rendered.indexOf(placeholder);
+		if (idx < 0) continue;
+		const r = argResults[i];
+		let replacement = "true";
+		if (r !== null) {
+			const conds = [
+				...r.schemaConditions,
+				...r.nameConditions,
+				...r.visibilityConditions
+			];
+			if (conds.length > 0) {
+				const slotOffset = params.length;
+				const renumbered = conds.map((c) => c.replace(/\$(\d+)/g, (_, n) => `$${Number(n) + slotOffset}`));
+				params.push(...r.params);
+				replacement = `(${renumbered.join(" AND ")})`;
+			}
+		}
+		rendered = rendered.slice(0, idx) + replacement + rendered.slice(idx + placeholder.length);
+	}
+	return {
+		sql: rendered,
+		params
+	};
 };
 /**
- * Upstream `map_typename_pattern()`: a few aliases the user can type
- * (`int`, `float`, `decimal`, …) get rewritten to the canonical type
- * names that appear in `pg_type.typname` / `format_type()`. Mirrors
- * `describe.c::map_typename_pattern`. Pattern matching is otherwise
- * literal, so this is the only place the user's input gets rewritten.
- */
+* Upstream `map_typename_pattern()`: a few aliases the user can type
+* (`int`, `float`, `decimal`, …) get rewritten to the canonical type
+* names that appear in `pg_type.typname` / `format_type()`. Mirrors
+* `describe.c::map_typename_pattern`. Pattern matching is otherwise
+* literal, so this is the only place the user's input gets rewritten.
+*/
 const TYPENAME_ALIASES = {
-    decimal: "numeric",
-    float: "double precision",
-    int: "integer",
-    "bool[]": "boolean[]",
-    "decimal[]": "numeric[]",
-    "float[]": "double precision[]",
-    "float4[]": "real[]",
-    "float8[]": "double precision[]",
-    "int[]": "integer[]",
-    "int2[]": "smallint[]",
-    "int4[]": "integer[]",
-    "int8[]": "bigint[]",
-    "time[]": "time without time zone[]",
-    "timetz[]": "time with time zone[]",
-    "timestamp[]": "timestamp without time zone[]",
-    "timestamptz[]": "timestamp with time zone[]",
-    "varbit[]": "bit varying[]",
-    "varchar[]": "character varying[]",
+	decimal: "numeric",
+	float: "double precision",
+	int: "integer",
+	"bool[]": "boolean[]",
+	"decimal[]": "numeric[]",
+	"float[]": "double precision[]",
+	"float4[]": "real[]",
+	"float8[]": "double precision[]",
+	"int[]": "integer[]",
+	"int2[]": "smallint[]",
+	"int4[]": "integer[]",
+	"int8[]": "bigint[]",
+	"time[]": "time without time zone[]",
+	"timetz[]": "time with time zone[]",
+	"timestamp[]": "timestamp without time zone[]",
+	"timestamptz[]": "timestamp with time zone[]",
+	"varbit[]": "bit varying[]",
+	"varchar[]": "character varying[]"
 };
 const mapTypenamePattern = (pattern) => TYPENAME_ALIASES[pattern.toLowerCase()] ?? pattern;
 /**
- * Process a per-argument type pattern slot for `\df` / `\do`. `-`
- * returns null (the SQL builder handles the literal `IS NULL` check);
- * any other value goes through {@link processSQLNamePattern} configured
- * with the `t<i>` / `nt<i>` join columns and the formatted-type
- * altnamevar so `\df foo int4` matches `oid -> integer` correctly.
- */
+* Process a per-argument type pattern slot for `\df` / `\do`. `-`
+* returns null (the SQL builder handles the literal `IS NULL` check);
+* any other value goes through {@link processSQLNamePattern} configured
+* with the `t<i>` / `nt<i>` join columns and the formatted-type
+* altnamevar so `\df foo int4` matches `oid -> integer` correctly.
+*/
 const processArgPattern = (slot, raw) => {
-    if (raw === "-")
-        return null;
-    const mapped = mapTypenamePattern(raw);
-    return processSQLNamePattern({
-        pattern: mapped,
-        schemavar: `nt${slot}.nspname`,
-        namevar: `t${slot}.typname`,
-        altnamevar: `pg_catalog.format_type(t${slot}.oid, NULL)`,
-        visibilityrule: `pg_catalog.pg_type_is_visible(t${slot}.oid)`,
-    });
+	if (raw === "-") return null;
+	const mapped = mapTypenamePattern(raw);
+	return processSQLNamePattern({
+		pattern: mapped,
+		schemavar: `nt${slot}.nspname`,
+		namevar: `t${slot}.typname`,
+		altnamevar: `pg_catalog.format_type(t${slot}.oid, NULL)`,
+		visibilityrule: `pg_catalog.pg_type_is_visible(t${slot}.oid)`
+	});
 };
 /**
- * Drive a `\df` / `\do` style command: collect the main pattern, then
- * any extra args as per-arg type filters, splice them all into the
- * query, and print. Returns the collected arg patterns so the SQL
- * builder upstream can mirror them as joins.
- */
+* Drive a `\df` / `\do` style command: collect the main pattern, then
+* any extra args as per-arg type filters, splice them all into the
+* query, and print. Returns the collected arg patterns so the SQL
+* builder upstream can mirror them as joins.
+*/
 const collectArgPatterns = (ctx) => {
-    const args = [];
-    // Upstream caps `\do` at 2 args internally but reads all of them
-    // from the scanner; describeFunctions caps at FUNC_MAX_ARGS (100).
-    // We let the caller decide what to do with extras (mostly: ignore).
-    for (;;) {
-        const arg = ctx.nextArg("normal");
-        if (arg === null)
-            break;
-        args.push(arg);
-    }
-    return args;
+	const args = [];
+	for (;;) {
+		const arg = ctx.nextArg("normal");
+		if (arg === null) break;
+		args.push(arg);
+	}
+	return args;
 };
 /**
- * Run a `\df` / `\do` query: handles the main pattern AND the per-arg
- * type filters in one go. Mirrors {@link runWithPattern}, but also
- * threads per-arg `NamePatternResult`s into the `ARG_PATTERN_<i>`
- * placeholders before handing off to {@link runListQuery}.
- */
+* Run a `\df` / `\do` query: handles the main pattern AND the per-arg
+* type filters in one go. Mirrors {@link runWithPattern}, but also
+* threads per-arg `NamePatternResult`s into the `ARG_PATTERN_<i>`
+* placeholders before handing off to {@link runListQuery}.
+*/
 const runFunctionOrOperatorQuery = async (ctx, pattern, argPatternResults, query, patternOpts) => {
-    const c = conn(ctx);
-    if (!c)
-        return noConn(ctx);
-    const result = processSQLNamePattern({ ...patternOpts, pattern });
-    const dotErr = validatePattern(pattern, result, 2, currentDb(c));
-    if (dotErr !== null) {
-        writeErr(`${dotErr}\n`);
-        return { status: "error", errorWritten: true };
-    }
-    // Substitute the arg-pattern placeholders first so the params they
-    // contribute precede the main pattern's `$N` allocations.
-    const { sql, params } = applyArgPatterns(query.sql, query.params, argPatternResults);
-    const finalQuery = {
-        ...query,
-        sql,
-        params,
-    };
-    try {
-        await runListQuery(c, finalQuery, result, process.stdout, ctx.settings.popt);
-        return { status: "ok" };
-    }
-    catch (err) {
-        writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
-        return { status: "error", errorWritten: true };
-    }
+	const c = conn(ctx);
+	if (!c) return noConn(ctx);
+	const result = processSQLNamePattern({
+		...patternOpts,
+		pattern
+	});
+	const dotErr = validatePattern(pattern, result, 2, currentDb(c));
+	if (dotErr !== null) {
+		writeErr(`${dotErr}\n`);
+		return {
+			status: "error",
+			errorWritten: true
+		};
+	}
+	const { sql, params } = applyArgPatterns(query.sql, query.params, argPatternResults);
+	const finalQuery = {
+		...query,
+		sql,
+		params
+	};
+	try {
+		await runListQuery(c, finalQuery, result, process.stdout, ctx.settings.popt);
+		return { status: "ok" };
+	} catch (err) {
+		writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
+		return {
+			status: "error",
+			errorWritten: true
+		};
+	}
 };
 const errMsg = (err) => err instanceof Error ? err.message : String(err);
-// ===========================================================================
-// Individual command specs
-// ===========================================================================
-// ---- \d / \d <name> / \dt / \di / \dv / \dm / \ds / \dE -------------------
 /** Bare `\d [pattern]` — list-or-detail. */
 const makeDescribeCmd = (baseName) => ({
-    name: baseName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose, showSystem } = decodeSuffix(ctx.cmdName, baseName);
-        // If pattern looks like a single concrete name (no wildcards),
-        // try a per-relation detail; otherwise list.
-        if (pattern && !/[*?]/.test(pattern)) {
-            // Pass the raw pattern straight through — lookupOneRelation folds /
-            // dequotes / splits schema.name via processSQLNamePattern.
-            try {
-                const rel = await lookupOneRelation(c, pattern);
-                if (rel) {
-                    await dispatchDetail(ctx, c, rel, verbose);
-                    return { status: "ok" };
-                }
-            }
-            catch (err) {
-                writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
-                return { status: "error", errorWritten: true };
-            }
-            // Fall through to list (mirrors upstream behaviour: if no exact
-            // relation, treat the name as a list pattern).
-        }
-        // `\d`-family `x` suffix toggles expanded mode for the LIST view
-        // only — upstream `command.c` declines to apply it when a pattern is
-        // present and would dispatch to per-relation detail rendering.
-        const forceExpanded = ctx.cmdName.slice(baseName.length).includes("x") &&
-            pattern === null;
-        const savedPopt = ctx.settings.popt;
-        if (forceExpanded) {
-            ctx.settings.popt = {
-                ...savedPopt,
-                topt: { ...savedPopt.topt, expanded: "on" },
-            };
-        }
-        try {
-            // List mode — use either describeTableDetails (for bare \d) or
-            // listTables(tabtypes=...) for the typed variants.
-            return await runTypedList(ctx, c, baseName, pattern, verbose, showSystem);
-        }
-        finally {
-            ctx.settings.popt = savedPopt;
-        }
-    },
+	name: baseName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose, showSystem } = decodeSuffix(ctx.cmdName, baseName);
+		if (pattern && !/[*?]/.test(pattern)) try {
+			const rel = await lookupOneRelation(c, pattern);
+			if (rel) {
+				await dispatchDetail(ctx, c, rel, verbose);
+				return { status: "ok" };
+			}
+		} catch (err) {
+			writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
+			return {
+				status: "error",
+				errorWritten: true
+			};
+		}
+		const forceExpanded = ctx.cmdName.slice(baseName.length).includes("x") && pattern === null;
+		const savedPopt = ctx.settings.popt;
+		if (forceExpanded) ctx.settings.popt = {
+			...savedPopt,
+			topt: {
+				...savedPopt.topt,
+				expanded: "on"
+			}
+		};
+		try {
+			return await runTypedList(ctx, c, baseName, pattern, verbose, showSystem);
+		} finally {
+			ctx.settings.popt = savedPopt;
+		}
+	}
 });
 const dispatchDetail = async (ctx, c, rel, verbose) => {
-    const popt = ctx.settings.popt;
-    switch (rel.relkind) {
-        case "S":
-            await describeOneSequence(c, rel.oid, rel.nspname, rel.relname, process.stdout, popt);
-            return;
-        case "v":
-            await describeOneViewDetails(c, rel.oid, rel.nspname, rel.relname, process.stdout, popt, verbose, ctx.settings.hideCompression);
-            return;
-        default:
-            await describeOneTableDetails(c, rel.oid, rel.nspname, rel.relname, rel.relkind, verbose, process.stdout, popt, ctx.settings.hideTableam, ctx.settings.hideCompression);
-    }
+	const popt = ctx.settings.popt;
+	switch (rel.relkind) {
+		case "S":
+			await describeOneSequence(c, rel.oid, rel.nspname, rel.relname, process.stdout, popt);
+			return;
+		case "v":
+			await describeOneViewDetails(c, rel.oid, rel.nspname, rel.relname, process.stdout, popt, verbose, ctx.settings.hideCompression);
+			return;
+		default: await describeOneTableDetails(c, rel.oid, rel.nspname, rel.relname, rel.relkind, verbose, process.stdout, popt, ctx.settings.hideTableam, ctx.settings.hideCompression);
+	}
 };
 const runTypedList = async (ctx, c, baseName, pattern, verbose, showSystem) => {
-    const serverVersion = c.serverVersion;
-    const hideTableam = ctx.settings.hideTableam;
-    let query;
-    let tabtypes = "";
-    switch (baseName) {
-        case "d":
-            query = describeTableDetails({
-                pattern: pattern ?? undefined,
-                verbose,
-                showSystem,
-                serverVersion,
-                hideTableam,
-            });
-            break;
-        case "dt":
-            tabtypes = "t";
-            query = listTables({
-                pattern: pattern ?? undefined,
-                verbose,
-                showSystem,
-                serverVersion,
-                tabtypes,
-                hideTableam,
-            });
-            break;
-        case "di":
-            tabtypes = "i";
-            query = listTables({
-                pattern: pattern ?? undefined,
-                verbose,
-                showSystem,
-                serverVersion,
-                tabtypes,
-                hideTableam,
-            });
-            break;
-        case "dv":
-            tabtypes = "v";
-            query = listTables({
-                pattern: pattern ?? undefined,
-                verbose,
-                showSystem,
-                serverVersion,
-                tabtypes,
-                hideTableam,
-            });
-            break;
-        case "dm":
-            tabtypes = "m";
-            query = listTables({
-                pattern: pattern ?? undefined,
-                verbose,
-                showSystem,
-                serverVersion,
-                tabtypes,
-                hideTableam,
-            });
-            break;
-        case "ds":
-            tabtypes = "s";
-            query = listTables({
-                pattern: pattern ?? undefined,
-                verbose,
-                showSystem,
-                serverVersion,
-                tabtypes,
-                hideTableam,
-            });
-            break;
-        case "dE":
-            tabtypes = "E";
-            query = listTables({
-                pattern: pattern ?? undefined,
-                verbose,
-                showSystem,
-                serverVersion,
-                tabtypes,
-                hideTableam,
-            });
-            break;
-        default:
-            return { status: "error" };
-    }
-    const visibility = baseName === "d"
-        ? "pg_catalog.pg_table_is_visible(c.oid)"
-        : "pg_catalog.pg_table_is_visible(c.oid)";
-    return runWithPattern(ctx, pattern, query, {
-        namevar: "c.relname",
-        schemavar: "n.nspname",
-        visibilityrule: visibility,
-    });
+	const serverVersion = c.serverVersion;
+	const hideTableam = ctx.settings.hideTableam;
+	let query;
+	let tabtypes = "";
+	switch (baseName) {
+		case "d":
+			query = describeTableDetails({
+				pattern: pattern ?? void 0,
+				verbose,
+				showSystem,
+				serverVersion,
+				hideTableam
+			});
+			break;
+		case "dt":
+			tabtypes = "t";
+			query = listTables({
+				pattern: pattern ?? void 0,
+				verbose,
+				showSystem,
+				serverVersion,
+				tabtypes,
+				hideTableam
+			});
+			break;
+		case "di":
+			tabtypes = "i";
+			query = listTables({
+				pattern: pattern ?? void 0,
+				verbose,
+				showSystem,
+				serverVersion,
+				tabtypes,
+				hideTableam
+			});
+			break;
+		case "dv":
+			tabtypes = "v";
+			query = listTables({
+				pattern: pattern ?? void 0,
+				verbose,
+				showSystem,
+				serverVersion,
+				tabtypes,
+				hideTableam
+			});
+			break;
+		case "dm":
+			tabtypes = "m";
+			query = listTables({
+				pattern: pattern ?? void 0,
+				verbose,
+				showSystem,
+				serverVersion,
+				tabtypes,
+				hideTableam
+			});
+			break;
+		case "ds":
+			tabtypes = "s";
+			query = listTables({
+				pattern: pattern ?? void 0,
+				verbose,
+				showSystem,
+				serverVersion,
+				tabtypes,
+				hideTableam
+			});
+			break;
+		case "dE":
+			tabtypes = "E";
+			query = listTables({
+				pattern: pattern ?? void 0,
+				verbose,
+				showSystem,
+				serverVersion,
+				tabtypes,
+				hideTableam
+			});
+			break;
+		default: return { status: "error" };
+	}
+	return runWithPattern(ctx, pattern, query, {
+		namevar: "c.relname",
+		schemavar: "n.nspname",
+		visibilityrule: baseName === "d" ? "pg_catalog.pg_table_is_visible(c.oid)" : "pg_catalog.pg_table_is_visible(c.oid)"
+	});
 };
-// Register all the relation-list-style commands with all suffix combos.
-const RELATION_BASES = ["d", "dt", "di", "dv", "dm", "ds", "dE"];
-// Standard suffix matrix. `x` is added separately for the bases that
-// accept the expanded-mode toggle (currently `\d`/`\d+`).
-const SUFFIX_COMBOS = ["", "+", "S", "S+", "+S"];
-// Extended suffix matrix for `\d` only — adds the `x` (expanded) suffix
-// in the same combinations regress exercises.
-const DESCRIBE_X_SUFFIXES = ["x", "+x", "x+", "Sx", "xS", "+Sx", "+xS"];
-// ---- \df / \df+ / \dfS / \dfa / \dfn / \dfp / \dft / \dfw / \dfx -------
-// Upstream's `command.c::exec_command_df` accepts a free-form suffix after
-// `\df`: `+` for verbose, `S` to include system schemas, `x` to force
-// expanded mode (when no pattern), and {a,n,p,t,w} to filter by function
-// kind (aggregate / normal / procedure / trigger / window). Multiple may
-// combine and order is unrestricted (`\dfax+`, `\df+xn`, etc.).
+const RELATION_BASES = [
+	"d",
+	"dt",
+	"di",
+	"dv",
+	"dm",
+	"ds",
+	"dE"
+];
+const SUFFIX_COMBOS = [
+	"",
+	"+",
+	"S",
+	"S+",
+	"+S"
+];
+const DESCRIBE_X_SUFFIXES = [
+	"x",
+	"+x",
+	"x+",
+	"Sx",
+	"xS",
+	"+Sx",
+	"+xS"
+];
 const cmdDescribeFunctions = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose, showSystem } = decodeSuffix(cmdName, "df");
-        let functypes = "";
-        const tail = cmdName.slice(2);
-        for (const ch of tail) {
-            if (ch === "a" ||
-                ch === "n" ||
-                ch === "p" ||
-                ch === "t" ||
-                ch === "w") {
-                functypes += ch;
-            }
-        }
-        // Per-argument type patterns: only collected when the main pattern
-        // is non-null (upstream: "Collect argument-type patterns too /
-        // otherwise it was just \df"). Each extra arg filters one slot of
-        // `proargtypes`; `-` means "no type in that slot".
-        const argPatterns = [];
-        if (pattern !== null) {
-            argPatterns.push(...collectArgPatterns(ctx));
-        }
-        const argPatternResults = argPatterns.map((a, i) => processArgPattern(i, a));
-        // `x` enables expanded mode for the printed result. For `\df` upstream
-        // applies the toggle whether or not a pattern is present (unlike `\d`,
-        // which only toggles when no pattern is given). Override popt locally
-        // so we don't leak the change to subsequent commands.
-        const forceExpanded = tail.includes("x");
-        const savedPopt = ctx.settings.popt;
-        if (forceExpanded) {
-            ctx.settings.popt = {
-                ...savedPopt,
-                topt: { ...savedPopt.topt, expanded: "on" },
-            };
-        }
-        try {
-            const query = describeFunctions({
-                pattern: pattern ?? undefined,
-                verbose,
-                showSystem,
-                functypes,
-                argPatterns,
-                serverVersion: c.serverVersion,
-            });
-            return await runFunctionOrOperatorQuery(ctx, pattern, argPatternResults, query, {
-                namevar: "p.proname",
-                schemavar: "n.nspname",
-                visibilityrule: "pg_catalog.pg_function_is_visible(p.oid)",
-            });
-        }
-        finally {
-            ctx.settings.popt = savedPopt;
-        }
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose, showSystem } = decodeSuffix(cmdName, "df");
+		let functypes = "";
+		const tail = cmdName.slice(2);
+		for (const ch of tail) if (ch === "a" || ch === "n" || ch === "p" || ch === "t" || ch === "w") functypes += ch;
+		const argPatterns = [];
+		if (pattern !== null) argPatterns.push(...collectArgPatterns(ctx));
+		const argPatternResults = argPatterns.map((a, i) => processArgPattern(i, a));
+		const forceExpanded = tail.includes("x");
+		const savedPopt = ctx.settings.popt;
+		if (forceExpanded) ctx.settings.popt = {
+			...savedPopt,
+			topt: {
+				...savedPopt.topt,
+				expanded: "on"
+			}
+		};
+		try {
+			const query = describeFunctions({
+				pattern: pattern ?? void 0,
+				verbose,
+				showSystem,
+				functypes,
+				argPatterns,
+				serverVersion: c.serverVersion
+			});
+			return await runFunctionOrOperatorQuery(ctx, pattern, argPatternResults, query, {
+				namevar: "p.proname",
+				schemavar: "n.nspname",
+				visibilityrule: "pg_catalog.pg_function_is_visible(p.oid)"
+			});
+		} finally {
+			ctx.settings.popt = savedPopt;
+		}
+	}
 });
-// ---- \da ----------------------------------------------------------------
 const cmdDescribeAggregates = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { showSystem } = decodeSuffix(cmdName, "da");
-        const query = describeAggregates({
-            pattern: pattern ?? undefined,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "p.proname",
-            schemavar: "n.nspname",
-            visibilityrule: "pg_catalog.pg_function_is_visible(p.oid)",
-        });
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { showSystem } = decodeSuffix(cmdName, "da");
+		const query = describeAggregates({
+			pattern: pattern ?? void 0,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "p.proname",
+			schemavar: "n.nspname",
+			visibilityrule: "pg_catalog.pg_function_is_visible(p.oid)"
+		});
+	}
 });
-// ---- \dA / \dA+ / \dAm / \dAm+ -----------------------------------------
-// `\dAm[+]` is a Neon extension: it lists access methods with their
-// handler and description columns always present, equivalent to upstream
-// `\dA+`. Upstream psql doesn't accept this spelling; we register it as
-// an alias so users who reach for "access methods" by full name get the
-// verbose view (Name, Type, Handler, Description) by default.
 const cmdDescribeAccessMethods = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const isAlias = cmdName.startsWith("dAm");
-        const base = isAlias ? "dAm" : "dA";
-        const { verbose } = decodeSuffix(cmdName, base);
-        // `\dAm[+]` always displays the verbose columns; trailing `+` is
-        // accepted for syntactic parity but doesn't change output.
-        const query = describeAccessMethods({
-            pattern: pattern ?? undefined,
-            verbose: isAlias ? true : verbose,
-            serverVersion: c.serverVersion,
-        });
-        // Access methods are global, never schema-qualified; first dot is
-        // "too many dotted names".
-        const result = await runWithPattern(ctx, pattern, query, { namevar: "amname" }, 0);
-        // Upstream `exec_command_d` drains any args past the first AFTER
-        // running the query and writing the result, emitting one warning
-        // per leftover token via `pg_log_warning`. Mirror that ordering so
-        // `\dA foo bar` prints the (empty) result first, then
-        // `\dA: extra argument "bar" ignored` to stderr.
-        for (let extra = ctx.nextArg("normal"); extra !== null;) {
-            writeErr(`\\${base}: extra argument "${extra}" ignored\n`);
-            extra = ctx.nextArg("normal");
-        }
-        return result;
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const isAlias = cmdName.startsWith("dAm");
+		const base = isAlias ? "dAm" : "dA";
+		const { verbose } = decodeSuffix(cmdName, base);
+		const query = describeAccessMethods({
+			pattern: pattern ?? void 0,
+			verbose: isAlias ? true : verbose,
+			serverVersion: c.serverVersion
+		});
+		const result = await runWithPattern(ctx, pattern, query, { namevar: "amname" }, 0);
+		for (let extra = ctx.nextArg("normal"); extra !== null;) {
+			writeErr(`\\${base}: extra argument "${extra}" ignored\n`);
+			extra = ctx.nextArg("normal");
+		}
+		return result;
+	}
 });
-// ---- \dAc / \dAc+ ------------------------------------------------------
-// `\dAc [AM-pattern [TYPE-pattern]]` — list operator classes. Two-pattern
-// command: the first arg filters by access-method name, the second by
-// input-type schema/name. Mirrors upstream's `case 'A' / cmd[2] == 'c'`
-// dispatch in `command.c::exec_command_d`.
 const cmdListOperatorClasses = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const amPat = ctx.nextArg("normal");
-        const typePat = amPat ? ctx.nextArg("normal") : null;
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(cmdName, "dAc");
-        const query = listOperatorClasses({
-            amPattern: amPat ?? undefined,
-            typePattern: typePat ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        const results = [];
-        const curDb = currentDb(c);
-        if (amPat !== null) {
-            const r = processSQLNamePattern({
-                namevar: "am.amname",
-                pattern: amPat,
-            });
-            // Access method names are flat — first dot is "too many".
-            const err = validatePattern(amPat, r, 0, curDb);
-            if (err !== null) {
-                writeErr(`${err}\n`);
-                return { status: "error", errorWritten: true };
-            }
-            results.push(r);
-        }
-        if (typePat !== null) {
-            const r = processSQLNamePattern({
-                namevar: "t.typname",
-                schemavar: "tn.nspname",
-                pattern: typePat,
-            });
-            // Type pattern accepts db.schema.name; cross-db check on 2-dot.
-            const err = validatePattern(typePat, r, 2, curDb);
-            if (err !== null) {
-                writeErr(`${err}\n`);
-                return { status: "error", errorWritten: true };
-            }
-            results.push(r);
-        }
-        return runDualPatternList(ctx, query, results);
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const amPat = ctx.nextArg("normal");
+		const typePat = amPat ? ctx.nextArg("normal") : null;
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(cmdName, "dAc");
+		const query = listOperatorClasses({
+			amPattern: amPat ?? void 0,
+			typePattern: typePat ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		const results = [];
+		const curDb = currentDb(c);
+		if (amPat !== null) {
+			const r = processSQLNamePattern({
+				namevar: "am.amname",
+				pattern: amPat
+			});
+			const err = validatePattern(amPat, r, 0, curDb);
+			if (err !== null) {
+				writeErr(`${err}\n`);
+				return {
+					status: "error",
+					errorWritten: true
+				};
+			}
+			results.push(r);
+		}
+		if (typePat !== null) {
+			const r = processSQLNamePattern({
+				namevar: "t.typname",
+				schemavar: "tn.nspname",
+				pattern: typePat
+			});
+			const err = validatePattern(typePat, r, 2, curDb);
+			if (err !== null) {
+				writeErr(`${err}\n`);
+				return {
+					status: "error",
+					errorWritten: true
+				};
+			}
+			results.push(r);
+		}
+		return runDualPatternList(ctx, query, results);
+	}
 });
-// ---- \dAf / \dAf+ ------------------------------------------------------
-// `\dAf [AM-pattern [TYPE-pattern]]` — list operator families. Same
-// two-pattern shape as `\dAc`. Routes through `listOperatorFamilies`
-// from queries.ts.
 const cmdListOperatorFamilies = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const amPat = ctx.nextArg("normal");
-        const typePat = amPat ? ctx.nextArg("normal") : null;
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(cmdName, "dAf");
-        const query = listOperatorFamilies({
-            amPattern: amPat ?? undefined,
-            typePattern: typePat ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        const results = [];
-        const curDb = currentDb(c);
-        if (amPat !== null) {
-            const r = processSQLNamePattern({
-                namevar: "am.amname",
-                pattern: amPat,
-            });
-            const err = validatePattern(amPat, r, 0, curDb);
-            if (err !== null) {
-                writeErr(`${err}\n`);
-                return { status: "error", errorWritten: true };
-            }
-            results.push(r);
-        }
-        if (typePat !== null) {
-            const r = processSQLNamePattern({
-                namevar: "t.typname",
-                schemavar: "tn.nspname",
-                pattern: typePat,
-            });
-            const err = validatePattern(typePat, r, 2, curDb);
-            if (err !== null) {
-                writeErr(`${err}\n`);
-                return { status: "error", errorWritten: true };
-            }
-            results.push(r);
-        }
-        return runDualPatternList(ctx, query, results);
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const amPat = ctx.nextArg("normal");
+		const typePat = amPat ? ctx.nextArg("normal") : null;
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(cmdName, "dAf");
+		const query = listOperatorFamilies({
+			amPattern: amPat ?? void 0,
+			typePattern: typePat ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		const results = [];
+		const curDb = currentDb(c);
+		if (amPat !== null) {
+			const r = processSQLNamePattern({
+				namevar: "am.amname",
+				pattern: amPat
+			});
+			const err = validatePattern(amPat, r, 0, curDb);
+			if (err !== null) {
+				writeErr(`${err}\n`);
+				return {
+					status: "error",
+					errorWritten: true
+				};
+			}
+			results.push(r);
+		}
+		if (typePat !== null) {
+			const r = processSQLNamePattern({
+				namevar: "t.typname",
+				schemavar: "tn.nspname",
+				pattern: typePat
+			});
+			const err = validatePattern(typePat, r, 2, curDb);
+			if (err !== null) {
+				writeErr(`${err}\n`);
+				return {
+					status: "error",
+					errorWritten: true
+				};
+			}
+			results.push(r);
+		}
+		return runDualPatternList(ctx, query, results);
+	}
 });
-// ---- \dAo / \dAo+ ------------------------------------------------------
-// `\dAo [AM-pattern [OPFAMILY-pattern]]` — list operators in an opfamily.
-// Routes through `listOpFamilyOperators` from queries.ts.
 const cmdListOpFamilyOperators = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const amPat = ctx.nextArg("normal");
-        const familyPat = amPat ? ctx.nextArg("normal") : null;
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(cmdName, "dAo");
-        const query = listOpFamilyOperators({
-            amPattern: amPat ?? undefined,
-            familyPattern: familyPat ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        const results = [];
-        const curDb = currentDb(c);
-        if (amPat !== null) {
-            const r = processSQLNamePattern({
-                namevar: "am.amname",
-                pattern: amPat,
-            });
-            const err = validatePattern(amPat, r, 0, curDb);
-            if (err !== null) {
-                writeErr(`${err}\n`);
-                return { status: "error", errorWritten: true };
-            }
-            results.push(r);
-        }
-        if (familyPat !== null) {
-            const r = processSQLNamePattern({
-                namevar: "of.opfname",
-                schemavar: "nsf.nspname",
-                pattern: familyPat,
-            });
-            const err = validatePattern(familyPat, r, 2, curDb);
-            if (err !== null) {
-                writeErr(`${err}\n`);
-                return { status: "error", errorWritten: true };
-            }
-            results.push(r);
-        }
-        return runDualPatternList(ctx, query, results);
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const amPat = ctx.nextArg("normal");
+		const familyPat = amPat ? ctx.nextArg("normal") : null;
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(cmdName, "dAo");
+		const query = listOpFamilyOperators({
+			amPattern: amPat ?? void 0,
+			familyPattern: familyPat ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		const results = [];
+		const curDb = currentDb(c);
+		if (amPat !== null) {
+			const r = processSQLNamePattern({
+				namevar: "am.amname",
+				pattern: amPat
+			});
+			const err = validatePattern(amPat, r, 0, curDb);
+			if (err !== null) {
+				writeErr(`${err}\n`);
+				return {
+					status: "error",
+					errorWritten: true
+				};
+			}
+			results.push(r);
+		}
+		if (familyPat !== null) {
+			const r = processSQLNamePattern({
+				namevar: "of.opfname",
+				schemavar: "nsf.nspname",
+				pattern: familyPat
+			});
+			const err = validatePattern(familyPat, r, 2, curDb);
+			if (err !== null) {
+				writeErr(`${err}\n`);
+				return {
+					status: "error",
+					errorWritten: true
+				};
+			}
+			results.push(r);
+		}
+		return runDualPatternList(ctx, query, results);
+	}
 });
-// ---- \dAp / \dAp+ ------------------------------------------------------
-// `\dAp [AM-pattern [OPFAMILY-pattern]]` — list support functions of an
-// opfamily. Routes through `listOpFamilyFunctions` from queries.ts.
 const cmdListOpFamilyFunctions = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const amPat = ctx.nextArg("normal");
-        const familyPat = amPat ? ctx.nextArg("normal") : null;
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(cmdName, "dAp");
-        // `\dApx[+]` — expanded toggle, same convention as `\df`/`\z`.
-        const forceExpanded = cmdName.slice(3).includes("x");
-        const savedPopt = ctx.settings.popt;
-        if (forceExpanded) {
-            ctx.settings.popt = {
-                ...savedPopt,
-                topt: { ...savedPopt.topt, expanded: "on" },
-            };
-        }
-        try {
-            const query = listOpFamilyFunctions({
-                amPattern: amPat ?? undefined,
-                familyPattern: familyPat ?? undefined,
-                verbose,
-                serverVersion: c.serverVersion,
-            });
-            const results = [];
-            const curDb = currentDb(c);
-            if (amPat !== null) {
-                const r = processSQLNamePattern({
-                    namevar: "am.amname",
-                    pattern: amPat,
-                });
-                const err = validatePattern(amPat, r, 0, curDb);
-                if (err !== null) {
-                    writeErr(`${err}\n`);
-                    return { status: "error", errorWritten: true };
-                }
-                results.push(r);
-            }
-            if (familyPat !== null) {
-                const r = processSQLNamePattern({
-                    namevar: "of.opfname",
-                    schemavar: "ns.nspname",
-                    pattern: familyPat,
-                });
-                const err = validatePattern(familyPat, r, 2, curDb);
-                if (err !== null) {
-                    writeErr(`${err}\n`);
-                    return { status: "error", errorWritten: true };
-                }
-                results.push(r);
-            }
-            return await runDualPatternList(ctx, query, results);
-        }
-        finally {
-            ctx.settings.popt = savedPopt;
-        }
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const amPat = ctx.nextArg("normal");
+		const familyPat = amPat ? ctx.nextArg("normal") : null;
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(cmdName, "dAp");
+		const forceExpanded = cmdName.slice(3).includes("x");
+		const savedPopt = ctx.settings.popt;
+		if (forceExpanded) ctx.settings.popt = {
+			...savedPopt,
+			topt: {
+				...savedPopt.topt,
+				expanded: "on"
+			}
+		};
+		try {
+			const query = listOpFamilyFunctions({
+				amPattern: amPat ?? void 0,
+				familyPattern: familyPat ?? void 0,
+				verbose,
+				serverVersion: c.serverVersion
+			});
+			const results = [];
+			const curDb = currentDb(c);
+			if (amPat !== null) {
+				const r = processSQLNamePattern({
+					namevar: "am.amname",
+					pattern: amPat
+				});
+				const err = validatePattern(amPat, r, 0, curDb);
+				if (err !== null) {
+					writeErr(`${err}\n`);
+					return {
+						status: "error",
+						errorWritten: true
+					};
+				}
+				results.push(r);
+			}
+			if (familyPat !== null) {
+				const r = processSQLNamePattern({
+					namevar: "of.opfname",
+					schemavar: "ns.nspname",
+					pattern: familyPat
+				});
+				const err = validatePattern(familyPat, r, 2, curDb);
+				if (err !== null) {
+					writeErr(`${err}\n`);
+					return {
+						status: "error",
+						errorWritten: true
+					};
+				}
+				results.push(r);
+			}
+			return await runDualPatternList(ctx, query, results);
+		} finally {
+			ctx.settings.popt = savedPopt;
+		}
+	}
 });
-// ---- \dT / \dT+ / \dTS --------------------------------------------------
 const cmdDescribeTypes = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose, showSystem } = decodeSuffix(cmdName, "dT");
-        const query = describeTypes({
-            pattern: pattern ?? undefined,
-            verbose,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "t.typname",
-            schemavar: "n.nspname",
-            visibilityrule: "pg_catalog.pg_type_is_visible(t.oid)",
-        });
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose, showSystem } = decodeSuffix(cmdName, "dT");
+		const query = describeTypes({
+			pattern: pattern ?? void 0,
+			verbose,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "t.typname",
+			schemavar: "n.nspname",
+			visibilityrule: "pg_catalog.pg_type_is_visible(t.oid)"
+		});
+	}
 });
-// ---- \do / \do+ ---------------------------------------------------------
 const cmdDescribeOperators = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose, showSystem } = decodeSuffix(cmdName, "do");
-        // Upstream: same arg-collection rule as `\df` (only when main
-        // pattern is non-null). describeOperators caps at 2 args; we still
-        // forward the user's input so the SQL builder can decide which
-        // joins to emit.
-        let argPatterns = [];
-        if (pattern !== null) {
-            argPatterns = collectArgPatterns(ctx);
-        }
-        if (argPatterns.length > 2)
-            argPatterns = argPatterns.slice(0, 2);
-        const argPatternResults = argPatterns.map((a, i) => processArgPattern(i, a));
-        const query = describeOperators({
-            pattern: pattern ?? undefined,
-            verbose,
-            showSystem,
-            argPatterns,
-            serverVersion: c.serverVersion,
-        });
-        return runFunctionOrOperatorQuery(ctx, pattern, argPatternResults, query, {
-            namevar: "o.oprname",
-            schemavar: "n.nspname",
-            visibilityrule: "pg_catalog.pg_operator_is_visible(o.oid)",
-        });
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose, showSystem } = decodeSuffix(cmdName, "do");
+		let argPatterns = [];
+		if (pattern !== null) argPatterns = collectArgPatterns(ctx);
+		if (argPatterns.length > 2) argPatterns = argPatterns.slice(0, 2);
+		const argPatternResults = argPatterns.map((a, i) => processArgPattern(i, a));
+		const query = describeOperators({
+			pattern: pattern ?? void 0,
+			verbose,
+			showSystem,
+			argPatterns,
+			serverVersion: c.serverVersion
+		});
+		return runFunctionOrOperatorQuery(ctx, pattern, argPatternResults, query, {
+			namevar: "o.oprname",
+			schemavar: "n.nspname",
+			visibilityrule: "pg_catalog.pg_operator_is_visible(o.oid)"
+		});
+	}
 });
-// ---- \du / \dg / \dg+ / \du+ -------------------------------------------
 const cmdDescribeRoles = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const base = cmdName.startsWith("du") ? "du" : "dg";
-        const { verbose, showSystem } = decodeSuffix(cmdName, base);
-        const query = describeRoles({
-            pattern: pattern ?? undefined,
-            verbose,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        // Roles are global — first dot is "too many". Upstream calls
-        // `printQuery` with `default_footer = false` (describe.c
-        // `describeRoles`), so suppress the `(N rows)` counter for both
-        // populated and empty results to match `psql -E \du`.
-        return runWithPattern(ctx, pattern, query, { namevar: "r.rolname" }, 0, {
-            suppressDefaultFooter: true,
-        });
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const base = cmdName.startsWith("du") ? "du" : "dg";
+		const { verbose, showSystem } = decodeSuffix(cmdName, base);
+		const query = describeRoles({
+			pattern: pattern ?? void 0,
+			verbose,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "r.rolname" }, 0, { suppressDefaultFooter: true });
+	}
 });
-// ---- \drds -------------------------------------------------------------
-// `\drds [role-pattern [database-pattern]]` — list role-/database-level
-// configuration settings (`pg_db_role_setting`). Two-pattern command:
-// first arg filters by role, second by database. Empty results print a
-// stderr notice ("Did not find any settings…") when not in quiet mode,
-// mirroring upstream `describe.c::listDbRoleSettings`.
 const cmdListDbRoleSettings = {
-    name: "drds",
-    run: async (ctx) => {
-        const rolePat = ctx.nextArg("normal");
-        const dbPat = rolePat ? ctx.nextArg("normal") : null;
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const query = listDbRoleSettings({
-            pattern: rolePat ?? undefined,
-            pattern2: dbPat ?? undefined,
-            serverVersion: c.serverVersion,
-        });
-        const results = [];
-        const curDb = currentDb(c);
-        if (rolePat !== null) {
-            const r = processSQLNamePattern({
-                namevar: "r.rolname",
-                pattern: rolePat,
-            });
-            // Role names are flat — first dot is "too many".
-            const err = validatePattern(rolePat, r, 0, curDb);
-            if (err !== null) {
-                writeErr(`${err}\n`);
-                return { status: "error", errorWritten: true };
-            }
-            results.push(r);
-        }
-        if (dbPat !== null) {
-            const r = processSQLNamePattern({
-                namevar: "d.datname",
-                pattern: dbPat,
-            });
-            // Database names are top-level — first dot is "too many".
-            const err = validatePattern(dbPat, r, 0, curDb);
-            if (err !== null) {
-                writeErr(`${err}\n`);
-                return { status: "error", errorWritten: true };
-            }
-            results.push(r);
-        }
-        // Upstream deviates from the rest of describe.c here: when the
-        // result set is empty and we're not in --quiet, emit a stderr
-        // diagnostic instead of printing an empty table — the two-pattern
-        // shape makes confusion likely otherwise.
-        if (rolePat === null && dbPat === null) {
-            return runDualPatternList(ctx, query, results);
-        }
-        const { sql, params } = applyTwoPatterns(query.sql, [], results);
-        const finalQuery = {
-            ...query,
-            sql,
-            params,
-        };
-        try {
-            const rs = await c.query(sql, params);
-            if (rs.rows.length === 0 && !ctx.settings.quiet) {
-                if (rolePat !== null && dbPat !== null) {
-                    writeErr(`Did not find any settings for role "${rolePat}" and database "${dbPat}".\n`);
-                }
-                else if (rolePat !== null) {
-                    writeErr(`Did not find any settings for role "${rolePat}".\n`);
-                }
-                return { status: "ok" };
-            }
-            // Re-print via the standard runner so the title and formatting
-            // match peer list queries. We pass the already-substituted SQL
-            // and an empty pattern result so the second-pass replace is a
-            // no-op. (We accept the double-query cost on the small `\drds`
-            // path; alternatives require duplicating the printer plumbing.)
-            const empty = {
-                schemaConditions: [],
-                nameConditions: [],
-                visibilityConditions: [],
-                params: [],
-                dotCount: 0,
-                dbLiteral: null,
-            };
-            await runListQuery(c, finalQuery, empty, process.stdout, ctx.settings.popt);
-            return { status: "ok" };
-        }
-        catch (err) {
-            writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
-            return { status: "error", errorWritten: true };
-        }
-    },
+	name: "drds",
+	run: async (ctx) => {
+		const rolePat = ctx.nextArg("normal");
+		const dbPat = rolePat ? ctx.nextArg("normal") : null;
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const query = listDbRoleSettings({
+			pattern: rolePat ?? void 0,
+			pattern2: dbPat ?? void 0,
+			serverVersion: c.serverVersion
+		});
+		const results = [];
+		const curDb = currentDb(c);
+		if (rolePat !== null) {
+			const r = processSQLNamePattern({
+				namevar: "r.rolname",
+				pattern: rolePat
+			});
+			const err = validatePattern(rolePat, r, 0, curDb);
+			if (err !== null) {
+				writeErr(`${err}\n`);
+				return {
+					status: "error",
+					errorWritten: true
+				};
+			}
+			results.push(r);
+		}
+		if (dbPat !== null) {
+			const r = processSQLNamePattern({
+				namevar: "d.datname",
+				pattern: dbPat
+			});
+			const err = validatePattern(dbPat, r, 0, curDb);
+			if (err !== null) {
+				writeErr(`${err}\n`);
+				return {
+					status: "error",
+					errorWritten: true
+				};
+			}
+			results.push(r);
+		}
+		if (rolePat === null && dbPat === null) return runDualPatternList(ctx, query, results);
+		const { sql, params } = applyTwoPatterns(query.sql, [], results);
+		const finalQuery = {
+			...query,
+			sql,
+			params
+		};
+		try {
+			if ((await c.query(sql, params)).rows.length === 0 && !ctx.settings.quiet) {
+				if (rolePat !== null && dbPat !== null) writeErr(`Did not find any settings for role "${rolePat}" and database "${dbPat}".\n`);
+				else if (rolePat !== null) writeErr(`Did not find any settings for role "${rolePat}".\n`);
+				return { status: "ok" };
+			}
+			await runListQuery(c, finalQuery, {
+				schemaConditions: [],
+				nameConditions: [],
+				visibilityConditions: [],
+				params: [],
+				dotCount: 0,
+				dbLiteral: null
+			}, process.stdout, ctx.settings.popt);
+			return { status: "ok" };
+		} catch (err) {
+			writeErr(`\\${ctx.cmdName}: ${errMsg(err)}\n`);
+			return {
+				status: "error",
+				errorWritten: true
+			};
+		}
+	}
 };
-// ---- \dn / \dn+ / \dnS --------------------------------------------------
 const cmdListSchemas = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose, showSystem } = decodeSuffix(cmdName, "dn");
-        const query = listSchemas({
-            pattern: pattern ?? undefined,
-            verbose,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        // Schemas live in a single namespace; the optional qualifier slot
-        // is interpreted as a database name (cross-database check fires on
-        // mismatch). `maxDots = 1`.
-        return runWithPattern(ctx, pattern, query, { namevar: "n.nspname" }, 1);
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose, showSystem } = decodeSuffix(cmdName, "dn");
+		const query = listSchemas({
+			pattern: pattern ?? void 0,
+			verbose,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "n.nspname" }, 1);
+	}
 });
-// ---- \db / \db+ ---------------------------------------------------------
-// Tablespaces — not typically relevant on Neon. We still register so the
-// command exists; it returns an empty result against a managed deployment.
 const cmdDescribeTablespaces = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(cmdName, "db");
-        const query = describeTablespaces({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        // Tablespaces are flat — first dot is "too many".
-        return runWithPattern(ctx, pattern, query, { namevar: "spcname" }, 0);
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(cmdName, "db");
+		const query = describeTablespaces({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "spcname" }, 0);
+	}
 });
-// ---- \dD / \dDS / \dD+ -------------------------------------------------
 const cmdListDomains = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose, showSystem } = decodeSuffix(cmdName, "dD");
-        const query = listDomains({
-            pattern: pattern ?? undefined,
-            verbose,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "t.typname",
-            schemavar: "n.nspname",
-            visibilityrule: "pg_catalog.pg_type_is_visible(t.oid)",
-        });
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose, showSystem } = decodeSuffix(cmdName, "dD");
+		const query = listDomains({
+			pattern: pattern ?? void 0,
+			verbose,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "t.typname",
+			schemavar: "n.nspname",
+			visibilityrule: "pg_catalog.pg_type_is_visible(t.oid)"
+		});
+	}
 });
-// ---- \dc / \dcS / \dc+ -------------------------------------------------
 const cmdListConversions = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose, showSystem } = decodeSuffix(cmdName, "dc");
-        const query = listConversions({
-            pattern: pattern ?? undefined,
-            verbose,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "c.conname",
-            schemavar: "n.nspname",
-            visibilityrule: "pg_catalog.pg_conversion_is_visible(c.oid)",
-        });
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose, showSystem } = decodeSuffix(cmdName, "dc");
+		const query = listConversions({
+			pattern: pattern ?? void 0,
+			verbose,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "c.conname",
+			schemavar: "n.nspname",
+			visibilityrule: "pg_catalog.pg_conversion_is_visible(c.oid)"
+		});
+	}
 });
-// ---- \dC / \dC+ --------------------------------------------------------
 const cmdListCasts = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(cmdName, "dC");
-        const query = listCasts({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "ts.typname",
-            schemavar: "ns.nspname",
-        });
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(cmdName, "dC");
+		const query = listCasts({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "ts.typname",
+			schemavar: "ns.nspname"
+		});
+	}
 });
-// ---- \dL / \dLS / \dL+ -------------------------------------------------
 const cmdListLanguages = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose, showSystem } = decodeSuffix(cmdName, "dL");
-        const query = listLanguages({
-            pattern: pattern ?? undefined,
-            verbose,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        // Languages are global; first dot is a database qualifier (cross-db).
-        return runWithPattern(ctx, pattern, query, { namevar: "l.lanname" }, 1);
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose, showSystem } = decodeSuffix(cmdName, "dL");
+		const query = listLanguages({
+			pattern: pattern ?? void 0,
+			verbose,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "l.lanname" }, 1);
+	}
 });
-// ---- \dO / \dO+ / \dOS -------------------------------------------------
 const cmdListCollations = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose, showSystem } = decodeSuffix(cmdName, "dO");
-        const query = listCollations({
-            pattern: pattern ?? undefined,
-            verbose,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "c.collname",
-            schemavar: "n.nspname",
-            visibilityrule: "pg_catalog.pg_collation_is_visible(c.oid)",
-        });
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose, showSystem } = decodeSuffix(cmdName, "dO");
+		const query = listCollations({
+			pattern: pattern ?? void 0,
+			verbose,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "c.collname",
+			schemavar: "n.nspname",
+			visibilityrule: "pg_catalog.pg_collation_is_visible(c.oid)"
+		});
+	}
 });
-// ---- \dp / \z ----------------------------------------------------------
 const cmdPermissionsList = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const base = cmdName.startsWith("z") ? "z" : "dp";
-        const { showSystem } = decodeSuffix(cmdName, base);
-        // `\z[x]`, `\dp[x]` — same expanded-mode toggle convention as `\df`,
-        // applied whether or not a pattern is present.
-        const forceExpanded = cmdName.slice(base.length).includes("x");
-        const savedPopt = ctx.settings.popt;
-        if (forceExpanded) {
-            ctx.settings.popt = {
-                ...savedPopt,
-                topt: { ...savedPopt.topt, expanded: "on" },
-            };
-        }
-        try {
-            const query = permissionsList({
-                pattern: pattern ?? undefined,
-                showSystem,
-                serverVersion: c.serverVersion,
-            });
-            return await runWithPattern(ctx, pattern, query, {
-                namevar: "c.relname",
-                schemavar: "n.nspname",
-                visibilityrule: "pg_catalog.pg_table_is_visible(c.oid)",
-            });
-        }
-        finally {
-            ctx.settings.popt = savedPopt;
-        }
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const base = cmdName.startsWith("z") ? "z" : "dp";
+		const { showSystem } = decodeSuffix(cmdName, base);
+		const forceExpanded = cmdName.slice(base.length).includes("x");
+		const savedPopt = ctx.settings.popt;
+		if (forceExpanded) ctx.settings.popt = {
+			...savedPopt,
+			topt: {
+				...savedPopt.topt,
+				expanded: "on"
+			}
+		};
+		try {
+			const query = permissionsList({
+				pattern: pattern ?? void 0,
+				showSystem,
+				serverVersion: c.serverVersion
+			});
+			return await runWithPattern(ctx, pattern, query, {
+				namevar: "c.relname",
+				schemavar: "n.nspname",
+				visibilityrule: "pg_catalog.pg_table_is_visible(c.oid)"
+			});
+		} finally {
+			ctx.settings.popt = savedPopt;
+		}
+	}
 });
-// ---- \ddp --------------------------------------------------------------
 const cmdListDefaultACLs = {
-    name: "ddp",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const query = listDefaultACLs({
-            pattern: pattern ?? undefined,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "pg_catalog.pg_get_userbyid(d.defaclrole)",
-            schemavar: "n.nspname",
-        });
-    },
+	name: "ddp",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const query = listDefaultACLs({
+			pattern: pattern ?? void 0,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "pg_catalog.pg_get_userbyid(d.defaclrole)",
+			schemavar: "n.nspname"
+		});
+	}
 };
-// ---- \dd ---------------------------------------------------------------
 const cmdObjectDescription = {
-    name: "dd",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { showSystem } = decodeSuffix(ctx.cmdName, "dd");
-        const query = objectDescription({
-            pattern: pattern ?? undefined,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "tt.name",
-            schemavar: "tt.nspname",
-        });
-    },
+	name: "dd",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { showSystem } = decodeSuffix(ctx.cmdName, "dd");
+		const query = objectDescription({
+			pattern: pattern ?? void 0,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "tt.name",
+			schemavar: "tt.nspname"
+		});
+	}
 };
-// ---- \l / \list -------------------------------------------------------
 const cmdListAllDbs = {
-    name: "l",
-    aliases: ["list"],
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "l");
-        const query = listAllDbs({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, { namevar: "d.datname" });
-    },
+	name: "l",
+	aliases: ["list"],
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "l");
+		const query = listAllDbs({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "d.datname" });
+	}
 };
-// ---- \dconfig ----------------------------------------------------------
 const cmdDescribeConfigParams = {
-    name: "dconfig",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dconfig");
-        const query = describeConfigurationParameters({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        // GUC names are flat — any dot is "too many".
-        return runWithPattern(ctx, pattern, query, { namevar: "pg_catalog.lower(s.name)" }, 0);
-    },
+	name: "dconfig",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dconfig");
+		const query = describeConfigurationParameters({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "pg_catalog.lower(s.name)" }, 0);
+	}
 };
-// ---- \dy ---------------------------------------------------------------
 const cmdListEventTriggers = {
-    name: "dy",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dy");
-        const query = listEventTriggers({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        // Event triggers are global with no schema or database qualifier
-        // (upstream `validateSQLNamePattern(..., NULL, 1)`): any dot in
-        // the pattern is "too many".
-        return runWithPattern(ctx, pattern, query, { namevar: "evtname" }, 0);
-    },
+	name: "dy",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dy");
+		const query = listEventTriggers({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "evtname" }, 0);
+	}
 };
-// ---- \dx / \dx+ -------------------------------------------------------
 const cmdListExtensions = {
-    name: "dx",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const query = listExtensions({
-            pattern: pattern ?? undefined,
-            serverVersion: c.serverVersion,
-        });
-        // Extensions are global with no schema or database qualifier
-        // (upstream `validateSQLNamePattern(..., NULL, 1)`): any dot is
-        // "too many".
-        return runWithPattern(ctx, pattern, query, { namevar: "e.extname" }, 0);
-    },
+	name: "dx",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const query = listExtensions({
+			pattern: pattern ?? void 0,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "e.extname" }, 0);
+	}
 };
-// ---- \dl / \lo_list ---------------------------------------------------
 const cmdListLargeObjects = {
-    name: "dl",
-    aliases: ["lo_list"],
-    run: async (ctx) => {
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dl");
-        const query = listLargeObjects({
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, null, query, { namevar: "oid" });
-    },
+	name: "dl",
+	aliases: ["lo_list"],
+	run: async (ctx) => {
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dl");
+		const query = listLargeObjects({
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, null, query, { namevar: "oid" });
+	}
 };
-// ---- \dF / \dFp / \dFd / \dFt ----------------------------------------
 const cmdListTSConfigs = {
-    name: "dF",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dF");
-        const query = listTSConfigs({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "c.cfgname",
-            schemavar: "n.nspname",
-        });
-    },
+	name: "dF",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dF");
+		const query = listTSConfigs({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "c.cfgname",
+			schemavar: "n.nspname"
+		});
+	}
 };
 const cmdListTSParsers = {
-    name: "dFp",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dFp");
-        const query = listTSParsers({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "p.prsname",
-            schemavar: "n.nspname",
-        });
-    },
+	name: "dFp",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dFp");
+		const query = listTSParsers({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "p.prsname",
+			schemavar: "n.nspname"
+		});
+	}
 };
 const cmdListTSDictionaries = {
-    name: "dFd",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dFd");
-        const query = listTSDictionaries({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "d.dictname",
-            schemavar: "n.nspname",
-        });
-    },
+	name: "dFd",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dFd");
+		const query = listTSDictionaries({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "d.dictname",
+			schemavar: "n.nspname"
+		});
+	}
 };
 const cmdListTSTemplates = {
-    name: "dFt",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dFt");
-        const query = listTSTemplates({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "t.tmplname",
-            schemavar: "n.nspname",
-        });
-    },
+	name: "dFt",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dFt");
+		const query = listTSTemplates({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "t.tmplname",
+			schemavar: "n.nspname"
+		});
+	}
 };
-// ---- \dew / \des / \deu / \det ---------------------------------------
 const cmdListForeignDataWrappers = {
-    name: "dew",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dew");
-        const query = listForeignDataWrappers({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        // FDWs are global with no schema or database qualifier (upstream
-        // `validateSQLNamePattern(..., NULL, 1)`): any dot is "too many".
-        return runWithPattern(ctx, pattern, query, { namevar: "fdwname" }, 0);
-    },
+	name: "dew",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dew");
+		const query = listForeignDataWrappers({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "fdwname" }, 0);
+	}
 };
 const cmdListForeignServers = {
-    name: "des",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "des");
-        const query = listForeignServers({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        // Foreign servers are global with no schema or database qualifier
-        // (upstream `validateSQLNamePattern(..., NULL, 1)`): any dot is
-        // "too many".
-        return runWithPattern(ctx, pattern, query, { namevar: "s.srvname" }, 0);
-    },
+	name: "des",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "des");
+		const query = listForeignServers({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "s.srvname" }, 0);
+	}
 };
 const cmdListUserMappings = {
-    name: "deu",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "deu");
-        const query = listUserMappings({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        // User mappings live alongside foreign servers (global, no schema
-        // or db qualifier per upstream `validateSQLNamePattern(..., 1)`).
-        return runWithPattern(ctx, pattern, query, { namevar: "um.srvname" }, 0);
-    },
+	name: "deu",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "deu");
+		const query = listUserMappings({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "um.srvname" }, 0);
+	}
 };
 const cmdListForeignTables = {
-    name: "det",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "det");
-        const query = listForeignTables({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "c.relname",
-            schemavar: "n.nspname",
-        });
-    },
+	name: "det",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "det");
+		const query = listForeignTables({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "c.relname",
+			schemavar: "n.nspname"
+		});
+	}
 };
-// ---- \dP / \dPi / \dPt / \dPn -----------------------------------------
 const cmdListPartitionedTables = {
-    name: "dP",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dP");
-        let reltypes = "";
-        if (ctx.cmdName.includes("i"))
-            reltypes += "i";
-        if (ctx.cmdName.includes("t"))
-            reltypes += "t";
-        if (ctx.cmdName.includes("n"))
-            reltypes += "n";
-        const query = listPartitionedTables({
-            pattern: pattern ?? undefined,
-            verbose,
-            reltypes,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "c.relname",
-            schemavar: "n.nspname",
-        });
-    },
+	name: "dP",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dP");
+		let reltypes = "";
+		if (ctx.cmdName.includes("i")) reltypes += "i";
+		if (ctx.cmdName.includes("t")) reltypes += "t";
+		if (ctx.cmdName.includes("n")) reltypes += "n";
+		const query = listPartitionedTables({
+			pattern: pattern ?? void 0,
+			verbose,
+			reltypes,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "c.relname",
+			schemavar: "n.nspname"
+		});
+	}
 };
-// ---- \dX / \dX+ -------------------------------------------------------
-// Extended-statistics objects (`pg_statistic_ext`). Patterns accept the
-// usual schema-qualified form: `\dX` schema.name, with the cross-database
-// 2-dot check applied.
 const cmdListExtendedStats = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(cmdName, "dX");
-        const query = listExtendedStats({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, {
-            namevar: "es.stxname",
-            schemavar: "es.stxnamespace::pg_catalog.regnamespace::pg_catalog.text",
-        });
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(cmdName, "dX");
+		const query = listExtendedStats({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, {
+			namevar: "es.stxname",
+			schemavar: "es.stxnamespace::pg_catalog.regnamespace::pg_catalog.text"
+		});
+	}
 });
-// ---- \drg / \drg+ -----------------------------------------------------
-// Role grants — membership rows from `pg_auth_members`. Two-pattern shape
-// is upstream-specific to `\du`/`\dg`; `\drg` carries the same pattern as
-// `\du` (role name), with the cross-database check declined because roles
-// are global.
 const cmdDescribeRoleGrants = (cmdName) => ({
-    name: cmdName,
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { showSystem } = decodeSuffix(cmdName, "drg");
-        const query = describeRoleGrants({
-            pattern: pattern ?? undefined,
-            showSystem,
-            serverVersion: c.serverVersion,
-        });
-        return runWithPattern(ctx, pattern, query, { namevar: "m.rolname" }, 0);
-    },
+	name: cmdName,
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { showSystem } = decodeSuffix(cmdName, "drg");
+		const query = describeRoleGrants({
+			pattern: pattern ?? void 0,
+			showSystem,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "m.rolname" }, 0);
+	}
 });
-// ---- \dRp / \dRs ------------------------------------------------------
 const cmdListPublications = {
-    name: "dRp",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const query = listPublications({
-            pattern: pattern ?? undefined,
-            serverVersion: c.serverVersion,
-        });
-        // Publications are global with no schema or database qualifier
-        // (upstream `validateSQLNamePattern(..., NULL, 1)`): any dot is
-        // "too many".
-        return runWithPattern(ctx, pattern, query, { namevar: "pubname" }, 0);
-    },
+	name: "dRp",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const query = listPublications({
+			pattern: pattern ?? void 0,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "pubname" }, 0);
+	}
 };
 const cmdDescribeSubscriptions = {
-    name: "dRs",
-    run: async (ctx) => {
-        const pattern = ctx.nextArg("normal");
-        const c = conn(ctx);
-        if (!c)
-            return noConn(ctx);
-        const { verbose } = decodeSuffix(ctx.cmdName, "dRs");
-        const query = describeSubscriptions({
-            pattern: pattern ?? undefined,
-            verbose,
-            serverVersion: c.serverVersion,
-        });
-        // Subscriptions are global with no schema or database qualifier
-        // (upstream `validateSQLNamePattern(..., NULL, 1)`): any dot is
-        // "too many".
-        return runWithPattern(ctx, pattern, query, { namevar: "subname" }, 0);
-    },
+	name: "dRs",
+	run: async (ctx) => {
+		const pattern = ctx.nextArg("normal");
+		const c = conn(ctx);
+		if (!c) return noConn(ctx);
+		const { verbose } = decodeSuffix(ctx.cmdName, "dRs");
+		const query = describeSubscriptions({
+			pattern: pattern ?? void 0,
+			verbose,
+			serverVersion: c.serverVersion
+		});
+		return runWithPattern(ctx, pattern, query, { namevar: "subname" }, 0);
+	}
 };
-// ===========================================================================
-// Registration
-// ===========================================================================
 /**
- * Register every `\d*` command this WP implements on the given
- * registry. Called from `dispatch.ts::defaultRegistry()`.
- *
- * We register a separate spec per suffix combination so the dispatcher
- * can do a single name lookup without re-parsing. The implementation
- * functions are factory-style (`make…(cmdName)`) so each spec carries
- * the exact command name for suffix decoding.
- */
-export const registerDescribeCommands = (registry) => {
-    // Relation list+detail family. Each suffix combination is its own
-    // registered name; suffix decoding happens at runtime via the
-    // `cmdName` field on the spec (set per-registration).
-    for (const base of RELATION_BASES) {
-        for (const suffix of SUFFIX_COMBOS) {
-            const name = base + suffix;
-            registry.register({ ...makeDescribeCmd(base), name });
-        }
-    }
-    // `\d` accepts an additional `x` (expanded-mode toggle) suffix that we
-    // register only for the bare `\d` base — upstream only honours it for
-    // `\d` itself, not for typed variants like `\dt` or `\dv`.
-    for (const suffix of DESCRIBE_X_SUFFIXES) {
-        registry.register({ ...makeDescribeCmd("d"), name: "d" + suffix });
-    }
-    // Functions. Beyond the standard `\df[+S]` matrix, upstream accepts
-    // function-kind filter letters (a / n / p / t / w) and an expanded-mode
-    // toggle (x) appended in any order, with multiple stacking. The fanout
-    // covers the common one-letter additions used in regress; combined
-    // letter sequences (`\dfax+`, `\dfxw`, …) are handled by the runtime
-    // suffix walk in `cmdDescribeFunctions`.
-    const dfTails = [
-        "",
-        "+",
-        "S",
-        "S+",
-        "+S",
-        "a",
-        "n",
-        "p",
-        "t",
-        "w",
-        "x",
-        "ax",
-        "nx",
-        "px",
-        "tx",
-        "wx",
-        "xa",
-        "xn",
-        "xp",
-        "xt",
-        "xw",
-        "a+",
-        "n+",
-        "p+",
-        "t+",
-        "w+",
-        "x+",
-        "a+x",
-        "x+a",
-    ];
-    for (const tail of dfTails) {
-        registry.register(cmdDescribeFunctions("df" + tail));
-    }
-    // Aggregates.
-    for (const suffix of ["", "S"]) {
-        registry.register(cmdDescribeAggregates("da" + suffix));
-    }
-    // Access methods. `\dA[+]` is upstream; `\dAm[+]` is a Neon-friendly
-    // alias that some docs reach for. `\dAc[+]`, `\dAf[+]`, `\dAo[+]`,
-    // `\dAp[+]` cover the operator-class / family / family-operator /
-    // family-function families upstream's `command.c::exec_command_d`
-    // dispatches.
-    for (const suffix of ["", "+"]) {
-        registry.register(cmdDescribeAccessMethods("dA" + suffix));
-        registry.register(cmdDescribeAccessMethods("dAm" + suffix));
-        registry.register(cmdListOperatorClasses("dAc" + suffix));
-        registry.register(cmdListOperatorFamilies("dAf" + suffix));
-        registry.register(cmdListOpFamilyOperators("dAo" + suffix));
-        registry.register(cmdListOpFamilyFunctions("dAp" + suffix));
-    }
-    // `x` (expanded) variants of the two-pattern access-method families.
-    for (const tail of ["x", "x+", "+x", "xS", "Sx"]) {
-        registry.register(cmdListOpFamilyFunctions("dAp" + tail));
-    }
-    // Types.
-    for (const suffix of SUFFIX_COMBOS) {
-        registry.register(cmdDescribeTypes("dT" + suffix));
-    }
-    // Operators.
-    for (const suffix of SUFFIX_COMBOS) {
-        registry.register(cmdDescribeOperators("do" + suffix));
-    }
-    // Roles.
-    for (const suffix of ["", "+", "S", "S+", "+S"]) {
-        registry.register(cmdDescribeRoles("du" + suffix));
-        registry.register(cmdDescribeRoles("dg" + suffix));
-    }
-    // Schemas.
-    for (const suffix of SUFFIX_COMBOS) {
-        registry.register(cmdListSchemas("dn" + suffix));
-    }
-    // Domains.
-    for (const suffix of SUFFIX_COMBOS) {
-        registry.register(cmdListDomains("dD" + suffix));
-    }
-    // Conversions.
-    for (const suffix of SUFFIX_COMBOS) {
-        registry.register(cmdListConversions("dc" + suffix));
-    }
-    // Casts.
-    for (const suffix of ["", "+"]) {
-        registry.register(cmdListCasts("dC" + suffix));
-    }
-    // Tablespaces.
-    for (const suffix of ["", "+"]) {
-        registry.register(cmdDescribeTablespaces("db" + suffix));
-    }
-    // Languages.
-    for (const suffix of SUFFIX_COMBOS) {
-        registry.register(cmdListLanguages("dL" + suffix));
-    }
-    // Collations.
-    for (const suffix of SUFFIX_COMBOS) {
-        registry.register(cmdListCollations("dO" + suffix));
-    }
-    // Permissions / default ACLs. `\dp` and `\z` are independent base names
-    // (aliasing them via `aliases` couldn't carry separate `x`-suffix
-    // variants), so register each with its own suffix matrix.
-    for (const tail of ["", "S", "x", "Sx", "xS"]) {
-        registry.register(cmdPermissionsList("dp" + tail));
-        registry.register(cmdPermissionsList("z" + tail));
-    }
-    registry.register(cmdListDefaultACLs);
-    // Descriptions.
-    registry.register(cmdObjectDescription);
-    // Databases. `\l`/`\list` plus their `+` (verbose) variants — the scanner
-    // folds the trailing `+` into the command name, so `\l+` needs its own
-    // registration or it dispatches to nothing. `decodeSuffix`
-    // reads the verbose flag back off `ctx.cmdName` at runtime.
-    registry.register(cmdListAllDbs);
-    registry.register({ ...cmdListAllDbs, name: "l+", aliases: ["list+"] });
-    // Config / event triggers / extensions / large objects.
-    registry.register(cmdDescribeConfigParams);
-    registry.register({ ...cmdDescribeConfigParams, name: "dconfig+" });
-    registry.register(cmdListEventTriggers);
-    registry.register(cmdListExtensions);
-    registry.register({ ...cmdListExtensions, name: "dx+" });
-    registry.register(cmdListLargeObjects);
-    // Text search family.
-    registry.register(cmdListTSConfigs);
-    registry.register({ ...cmdListTSConfigs, name: "dF+" });
-    registry.register(cmdListTSParsers);
-    registry.register({ ...cmdListTSParsers, name: "dFp+" });
-    registry.register(cmdListTSDictionaries);
-    registry.register({ ...cmdListTSDictionaries, name: "dFd+" });
-    registry.register(cmdListTSTemplates);
-    registry.register({ ...cmdListTSTemplates, name: "dFt+" });
-    // Foreign-data family.
-    for (const variant of ["dew", "dew+"]) {
-        registry.register({ ...cmdListForeignDataWrappers, name: variant });
-    }
-    for (const variant of ["des", "des+"]) {
-        registry.register({ ...cmdListForeignServers, name: variant });
-    }
-    for (const variant of ["deu", "deu+"]) {
-        registry.register({ ...cmdListUserMappings, name: variant });
-    }
-    for (const variant of ["det", "det+"]) {
-        registry.register({ ...cmdListForeignTables, name: variant });
-    }
-    // Partitioned tables. Upstream's `\dP` accepts any concatenation of
-    // {i,t,n}: `\dPtn` lists nested partitioned tables (table + nested
-    // toggles), `\dPin` lists nested partitioned indexes, etc. We
-    // register the most common combinations explicitly; the spec's
-    // suffix-decoding loop (`includes('i'|'t'|'n')`) drives the actual
-    // `reltypes` selection at runtime.
-    for (const variant of [
-        "dP",
-        "dP+",
-        "dPi",
-        "dPi+",
-        "dPin",
-        "dPin+",
-        "dPt",
-        "dPt+",
-        "dPtn",
-        "dPtn+",
-        "dPn",
-        "dPn+",
-    ]) {
-        registry.register({ ...cmdListPartitionedTables, name: variant });
-    }
-    // Role-database settings.
-    registry.register(cmdListDbRoleSettings);
-    registry.register({ ...cmdListDbRoleSettings, name: "drds+" });
-    // Extended statistics (\dX / \dX+).
-    for (const suffix of ["", "+"]) {
-        registry.register(cmdListExtendedStats("dX" + suffix));
-    }
-    // Role grants (\drg / \drg+ / \drgS).
-    for (const suffix of ["", "+", "S", "S+", "+S"]) {
-        registry.register(cmdDescribeRoleGrants("drg" + suffix));
-    }
-    // Publication / subscription.
-    for (const variant of ["dRp", "dRp+"]) {
-        registry.register({ ...cmdListPublications, name: variant });
-    }
-    for (const variant of ["dRs", "dRs+"]) {
-        registry.register({ ...cmdDescribeSubscriptions, name: variant });
-    }
+* Register every `\d*` command this WP implements on the given
+* registry. Called from `dispatch.ts::defaultRegistry()`.
+*
+* We register a separate spec per suffix combination so the dispatcher
+* can do a single name lookup without re-parsing. The implementation
+* functions are factory-style (`make…(cmdName)`) so each spec carries
+* the exact command name for suffix decoding.
+*/
+const registerDescribeCommands = (registry) => {
+	for (const base of RELATION_BASES) for (const suffix of SUFFIX_COMBOS) {
+		const name = base + suffix;
+		registry.register({
+			...makeDescribeCmd(base),
+			name
+		});
+	}
+	for (const suffix of DESCRIBE_X_SUFFIXES) registry.register({
+		...makeDescribeCmd("d"),
+		name: "d" + suffix
+	});
+	for (const tail of [
+		"",
+		"+",
+		"S",
+		"S+",
+		"+S",
+		"a",
+		"n",
+		"p",
+		"t",
+		"w",
+		"x",
+		"ax",
+		"nx",
+		"px",
+		"tx",
+		"wx",
+		"xa",
+		"xn",
+		"xp",
+		"xt",
+		"xw",
+		"a+",
+		"n+",
+		"p+",
+		"t+",
+		"w+",
+		"x+",
+		"a+x",
+		"x+a"
+	]) registry.register(cmdDescribeFunctions("df" + tail));
+	for (const suffix of ["", "S"]) registry.register(cmdDescribeAggregates("da" + suffix));
+	for (const suffix of ["", "+"]) {
+		registry.register(cmdDescribeAccessMethods("dA" + suffix));
+		registry.register(cmdDescribeAccessMethods("dAm" + suffix));
+		registry.register(cmdListOperatorClasses("dAc" + suffix));
+		registry.register(cmdListOperatorFamilies("dAf" + suffix));
+		registry.register(cmdListOpFamilyOperators("dAo" + suffix));
+		registry.register(cmdListOpFamilyFunctions("dAp" + suffix));
+	}
+	for (const tail of [
+		"x",
+		"x+",
+		"+x",
+		"xS",
+		"Sx"
+	]) registry.register(cmdListOpFamilyFunctions("dAp" + tail));
+	for (const suffix of SUFFIX_COMBOS) registry.register(cmdDescribeTypes("dT" + suffix));
+	for (const suffix of SUFFIX_COMBOS) registry.register(cmdDescribeOperators("do" + suffix));
+	for (const suffix of [
+		"",
+		"+",
+		"S",
+		"S+",
+		"+S"
+	]) {
+		registry.register(cmdDescribeRoles("du" + suffix));
+		registry.register(cmdDescribeRoles("dg" + suffix));
+	}
+	for (const suffix of SUFFIX_COMBOS) registry.register(cmdListSchemas("dn" + suffix));
+	for (const suffix of SUFFIX_COMBOS) registry.register(cmdListDomains("dD" + suffix));
+	for (const suffix of SUFFIX_COMBOS) registry.register(cmdListConversions("dc" + suffix));
+	for (const suffix of ["", "+"]) registry.register(cmdListCasts("dC" + suffix));
+	for (const suffix of ["", "+"]) registry.register(cmdDescribeTablespaces("db" + suffix));
+	for (const suffix of SUFFIX_COMBOS) registry.register(cmdListLanguages("dL" + suffix));
+	for (const suffix of SUFFIX_COMBOS) registry.register(cmdListCollations("dO" + suffix));
+	for (const tail of [
+		"",
+		"S",
+		"x",
+		"Sx",
+		"xS"
+	]) {
+		registry.register(cmdPermissionsList("dp" + tail));
+		registry.register(cmdPermissionsList("z" + tail));
+	}
+	registry.register(cmdListDefaultACLs);
+	registry.register(cmdObjectDescription);
+	registry.register(cmdListAllDbs);
+	registry.register({
+		...cmdListAllDbs,
+		name: "l+",
+		aliases: ["list+"]
+	});
+	registry.register(cmdDescribeConfigParams);
+	registry.register({
+		...cmdDescribeConfigParams,
+		name: "dconfig+"
+	});
+	registry.register(cmdListEventTriggers);
+	registry.register(cmdListExtensions);
+	registry.register({
+		...cmdListExtensions,
+		name: "dx+"
+	});
+	registry.register(cmdListLargeObjects);
+	registry.register(cmdListTSConfigs);
+	registry.register({
+		...cmdListTSConfigs,
+		name: "dF+"
+	});
+	registry.register(cmdListTSParsers);
+	registry.register({
+		...cmdListTSParsers,
+		name: "dFp+"
+	});
+	registry.register(cmdListTSDictionaries);
+	registry.register({
+		...cmdListTSDictionaries,
+		name: "dFd+"
+	});
+	registry.register(cmdListTSTemplates);
+	registry.register({
+		...cmdListTSTemplates,
+		name: "dFt+"
+	});
+	for (const variant of ["dew", "dew+"]) registry.register({
+		...cmdListForeignDataWrappers,
+		name: variant
+	});
+	for (const variant of ["des", "des+"]) registry.register({
+		...cmdListForeignServers,
+		name: variant
+	});
+	for (const variant of ["deu", "deu+"]) registry.register({
+		...cmdListUserMappings,
+		name: variant
+	});
+	for (const variant of ["det", "det+"]) registry.register({
+		...cmdListForeignTables,
+		name: variant
+	});
+	for (const variant of [
+		"dP",
+		"dP+",
+		"dPi",
+		"dPi+",
+		"dPin",
+		"dPin+",
+		"dPt",
+		"dPt+",
+		"dPtn",
+		"dPtn+",
+		"dPn",
+		"dPn+"
+	]) registry.register({
+		...cmdListPartitionedTables,
+		name: variant
+	});
+	registry.register(cmdListDbRoleSettings);
+	registry.register({
+		...cmdListDbRoleSettings,
+		name: "drds+"
+	});
+	for (const suffix of ["", "+"]) registry.register(cmdListExtendedStats("dX" + suffix));
+	for (const suffix of [
+		"",
+		"+",
+		"S",
+		"S+",
+		"+S"
+	]) registry.register(cmdDescribeRoleGrants("drg" + suffix));
+	for (const variant of ["dRp", "dRp+"]) registry.register({
+		...cmdListPublications,
+		name: variant
+	});
+	for (const variant of ["dRs", "dRs+"]) registry.register({
+		...cmdDescribeSubscriptions,
+		name: variant
+	});
 };
+//#endregion
+export { registerDescribeCommands };