neon 2.47.0 → 3.1.0

package/dist/psql/complete/rules.js

@@ -1,2424 +1,1618 @@
-/**
- * Tab-completion rule body.
- *
- * Port (selective — see "Coverage" below) of psql's `psql_completion()`
- * from `src/bin/psql/tab-complete.in.c`. Given the tokenized "previous
- * words" and the in-progress current word, we walk a chain of
- * Matches/TailMatches/HeadMatches guards and return:
- *
- *   - a STATIC list (for keyword / enum-value completion), filtered by the
- *     current word's prefix, OR
- *   - a CATALOG query (for table/view/role/schema/etc.) executed against
- *     the live Connection.
- *
- * Coverage (the parts of upstream we ship):
- *
- *   - Backslash command name completion: `\` → list of commands.
- *   - Backslash arg completion for the high-traffic commands: `\c[onnect]`,
- *     `\dt`/`\d`/`\dv`/`\dm`/`\di`/`\ds`, `\df`, `\dn`, `\du`/`\dg`,
- *     `\dx`, `\dL`, `\dT`, `\do` (operators), `\dC` (casts), `\encoding`,
- *     `\pset`, `\set`.
- *   - Top-level SQL keyword set (SELECT/INSERT/UPDATE/DELETE/etc).
- *   - Mid-statement object completion in the most common contexts:
- *       FROM            → tables/views/matviews/foreign tables.
- *       INTO (INSERT)   → tables.
- *       JOIN            → tables/views/matviews.
- *       UPDATE          → tables.
- *       DELETE FROM     → tables.
- *       ALTER TABLE     → tables, then sub-action (ADD/DROP/…),
- *                         then sub-action continuation (COLUMN/CONSTRAINT/…).
- *       ALTER VIEW      → views + sub-actions.
- *       ALTER MATERIALIZED VIEW → mat-views + sub-actions.
- *       ALTER INDEX     → indexes + sub-actions.
- *       ALTER SEQUENCE  → sequences + sub-actions.
- *       ALTER FUNCTION / PROCEDURE / ROUTINE → functions + sub-actions.
- *       ALTER TYPE      → types + sub-actions.
- *       ALTER ROLE/USER → roles + sub-actions.
- *       ALTER DATABASE  → databases + sub-actions.
- *       ALTER SCHEMA    → schemas + sub-actions.
- *       ALTER EXTENSION → extensions + sub-actions.
- *       ALTER POLICY    → ON <table>, rename/owner.
- *       ALTER PUBLICATION / SUBSCRIPTION → sub-actions.
- *       DROP TABLE      → tables.
- *       DROP VIEW       → views.
- *       DROP INDEX      → indexes.
- *       DROP MATERIALIZED VIEW → mat views.
- *       DROP SEQUENCE   → sequences.
- *       DROP TYPE       → types.
- *       DROP SCHEMA     → schemas.
- *       DROP EXTENSION  → extensions.
- *       DROP ROLE / USER → roles.
- *       DROP DATABASE   → databases.
- *       DROP FUNCTION   → functions.
- *       CREATE INDEX    → CONCURRENTLY / IF NOT EXISTS / ON / USING (access methods).
- *       GRANT / REVOKE … ON … → tables.
- *       TRUNCATE [TABLE] → tables.
- *       LOCK TABLE      → tables.
- *       COPY            → tables.
- *       ANALYZE / VACUUM → tables.
- *       REINDEX         → indexes/tables/databases (limited).
- *       SET <guc>       → list of GUC names from pg_settings.
- *       SET ROLE        → roles.
- *       SET SCHEMA      → schemas.
- *       SHOW <guc>      → list of GUC names from pg_settings.
- *       RESET <guc>     → list of GUC names from pg_settings.
- *
- *   - Window-function clauses: `OVER (` → PARTITION BY / ORDER BY / RANGE /
- *     ROWS / GROUPS.
- *   - Generic post-FROM/JOIN tail keywords: JOIN, WHERE, GROUP BY, ORDER BY,
- *     LIMIT, OFFSET, UNION, INTERSECT, EXCEPT, etc.
- *   - WHERE-expression continuations: AND / OR / IS / IN / NOT / BETWEEN.
- *   - `\set`/`\unset`: completion of psql variable names.
- *   - Variable expansion `:NAME` completion (inside any line).
- *
- * Upstream coverage notes (psql `tab-complete.in.c`):
- *   - We ported the ALTER-OBJECT arms around lines 2050-2700 (sub-actions
- *     for TABLE/VIEW/MV/INDEX/SEQUENCE/FUNCTION/TYPE/ROLE/DB/SCHEMA/
- *     EXTENSION/POLICY/PUBLICATION/SUBSCRIPTION) but elided the deep
- *     option-value continuations (e.g. ALTER TABLE … ADD CONSTRAINT …
- *     CHECK (…)) and partition-bound clauses.
- *   - We ported the post-FROM / JOIN tail-keyword set from lines ~4500-4700.
- *   - We ported the SET/SHOW/RESET GUC lookup from lines ~5500-5700, using
- *     a live pg_settings query rather than a static list.
- *   - We ported the CREATE INDEX block at ~3000-3100.
- *   - Skipped: ALTER-system fine-grained options, COMMENT ON full grammar,
- *     CREATE STATISTICS, CREATE EVENT TRIGGER bodies, FDW/USER MAPPING
- *     argument grammar, and most GRANT/REVOKE class continuations beyond
- *     the table object form.
- *
- * What's intentionally still stubbed:
- *
- *   - psql `\h` SQL help index — exists in psql proper, would need the
- *     help index data.
- *   - Column-name completion after `SELECT … FROM t WHERE` (we don't carry
- *     a parsed alias→relation map; upstream parses the FROM clause).
- *
- * The shape mirrors the C source closely enough that adding new rules is
- * mechanical: drop a new `if (TailMatches(...))` arm in the right region.
- */
+import { HeadMatches, TailMatches, tokenize } from "./matcher.js";
 import { completeFilenames, isCopyFromOrTo } from "./filenames.js";
-import { HeadMatches, MatchAny, TailMatches, tokenize } from "./matcher.js";
-import { ENCODINGS, PSET_OPTIONS, psetValuesFor, SPECIAL_VARIABLES, variableValuesFor, } from "./psqlVars.js";
-import { Query_for_constraint_of_table, Query_for_constraint_of_table_in_schema, Query_for_list_of_casts, Query_for_list_of_databases, Query_for_list_of_datatypes, Query_for_list_of_enum_values_quoted, Query_for_list_of_extensions, Query_for_list_of_functions, Query_for_list_of_index_access_methods, Query_for_list_of_indexes, Query_for_list_of_languages, Query_for_list_of_matviews, Query_for_list_of_operators, Query_for_list_of_publications, Query_for_list_of_relations_in_schema, Query_for_list_of_roles, Query_for_list_of_schemas, Query_for_list_of_sequences, Query_for_list_of_set_vars, Query_for_list_of_subscriptions, Query_for_list_of_tables, Query_for_list_of_tables_for_constraint, Query_for_list_of_tables_for_constraint_in_schema, Query_for_list_of_tables_views, Query_for_list_of_tablespaces, Query_for_list_of_timezone_names_quoted_in, Query_for_list_of_timezone_names_quoted_out, Query_for_list_of_types, Query_for_list_of_views, Query_for_values_of_enum_GUC, runCatalogQuery, } from "./queries.js";
+import { ENCODINGS, PSET_OPTIONS, SPECIAL_VARIABLES, psetValuesFor, variableValuesFor } from "./psqlVars.js";
+import { Query_for_constraint_of_table, Query_for_constraint_of_table_in_schema, Query_for_list_of_casts, Query_for_list_of_databases, Query_for_list_of_datatypes, Query_for_list_of_enum_values_quoted, Query_for_list_of_extensions, Query_for_list_of_functions, Query_for_list_of_index_access_methods, Query_for_list_of_indexes, Query_for_list_of_languages, Query_for_list_of_matviews, Query_for_list_of_operators, Query_for_list_of_publications, Query_for_list_of_relations_in_schema, Query_for_list_of_roles, Query_for_list_of_schemas, Query_for_list_of_sequences, Query_for_list_of_set_vars, Query_for_list_of_subscriptions, Query_for_list_of_tables, Query_for_list_of_tables_for_constraint, Query_for_list_of_tables_for_constraint_in_schema, Query_for_list_of_tables_views, Query_for_list_of_tablespaces, Query_for_list_of_timezone_names_quoted_in, Query_for_list_of_timezone_names_quoted_out, Query_for_list_of_types, Query_for_list_of_views, Query_for_values_of_enum_GUC, runCatalogQuery } from "./queries.js";
+//#region src/psql/complete/rules.ts
 /** Backslash command names psql tab-completes (mirrors backslash_commands[]). */
-export const BACKSLASH_COMMANDS = [
-    "\\a",
-    "\\bind",
-    "\\bind_named",
-    "\\c",
-    "\\C",
-    "\\cd",
-    "\\close_prepared",
-    "\\conninfo",
-    "\\connect",
-    "\\copy",
-    "\\copyright",
-    "\\crosstabview",
-    "\\d",
-    "\\dA",
-    "\\dAc",
-    "\\dAf",
-    "\\dAo",
-    "\\dAp",
-    "\\da",
-    "\\db",
-    "\\dC",
-    "\\dc",
-    "\\dconfig",
-    "\\dD",
-    "\\dd",
-    "\\ddp",
-    "\\dE",
-    "\\des",
-    "\\det",
-    "\\deu",
-    "\\dew",
-    "\\df",
-    "\\dF",
-    "\\dFd",
-    "\\dFp",
-    "\\dFt",
-    "\\dg",
-    "\\di",
-    "\\dl",
-    "\\dL",
-    "\\dm",
-    "\\dn",
-    "\\do",
-    "\\dO",
-    "\\dp",
-    "\\dP",
-    "\\dPi",
-    "\\dPt",
-    "\\drds",
-    "\\drg",
-    "\\dRs",
-    "\\dRp",
-    "\\ds",
-    "\\dt",
-    "\\dT",
-    "\\dv",
-    "\\du",
-    "\\dx",
-    "\\dX",
-    "\\dy",
-    "\\echo",
-    "\\edit",
-    "\\ef",
-    "\\elif",
-    "\\else",
-    "\\encoding",
-    "\\endif",
-    "\\endpipeline",
-    "\\errverbose",
-    "\\ev",
-    "\\f",
-    "\\flush",
-    "\\flushrequest",
-    "\\g",
-    "\\gdesc",
-    "\\getenv",
-    "\\getresults",
-    "\\gexec",
-    "\\gset",
-    "\\gx",
-    "\\help",
-    "\\html",
-    "\\if",
-    "\\include",
-    "\\include_relative",
-    "\\ir",
-    "\\l",
-    "\\list",
-    "\\lo_export",
-    "\\lo_import",
-    "\\lo_list",
-    "\\lo_unlink",
-    "\\o",
-    "\\out",
-    "\\parse",
-    "\\password",
-    "\\print",
-    "\\prompt",
-    "\\pset",
-    "\\q",
-    "\\qecho",
-    "\\quit",
-    "\\reset",
-    "\\restrict",
-    "\\s",
-    "\\sendpipeline",
-    "\\set",
-    "\\setenv",
-    "\\sf",
-    "\\startpipeline",
-    "\\sv",
-    "\\syncpipeline",
-    "\\t",
-    "\\T",
-    "\\timing",
-    "\\unrestrict",
-    "\\unset",
-    "\\w",
-    "\\warn",
-    "\\watch",
-    "\\write",
-    "\\x",
-    "\\z",
-    "\\!",
-    "\\?",
+const BACKSLASH_COMMANDS = [
+	"\\a",
+	"\\bind",
+	"\\bind_named",
+	"\\c",
+	"\\C",
+	"\\cd",
+	"\\close_prepared",
+	"\\conninfo",
+	"\\connect",
+	"\\copy",
+	"\\copyright",
+	"\\crosstabview",
+	"\\d",
+	"\\dA",
+	"\\dAc",
+	"\\dAf",
+	"\\dAo",
+	"\\dAp",
+	"\\da",
+	"\\db",
+	"\\dC",
+	"\\dc",
+	"\\dconfig",
+	"\\dD",
+	"\\dd",
+	"\\ddp",
+	"\\dE",
+	"\\des",
+	"\\det",
+	"\\deu",
+	"\\dew",
+	"\\df",
+	"\\dF",
+	"\\dFd",
+	"\\dFp",
+	"\\dFt",
+	"\\dg",
+	"\\di",
+	"\\dl",
+	"\\dL",
+	"\\dm",
+	"\\dn",
+	"\\do",
+	"\\dO",
+	"\\dp",
+	"\\dP",
+	"\\dPi",
+	"\\dPt",
+	"\\drds",
+	"\\drg",
+	"\\dRs",
+	"\\dRp",
+	"\\ds",
+	"\\dt",
+	"\\dT",
+	"\\dv",
+	"\\du",
+	"\\dx",
+	"\\dX",
+	"\\dy",
+	"\\echo",
+	"\\edit",
+	"\\ef",
+	"\\elif",
+	"\\else",
+	"\\encoding",
+	"\\endif",
+	"\\endpipeline",
+	"\\errverbose",
+	"\\ev",
+	"\\f",
+	"\\flush",
+	"\\flushrequest",
+	"\\g",
+	"\\gdesc",
+	"\\getenv",
+	"\\getresults",
+	"\\gexec",
+	"\\gset",
+	"\\gx",
+	"\\help",
+	"\\html",
+	"\\if",
+	"\\include",
+	"\\include_relative",
+	"\\ir",
+	"\\l",
+	"\\list",
+	"\\lo_export",
+	"\\lo_import",
+	"\\lo_list",
+	"\\lo_unlink",
+	"\\o",
+	"\\out",
+	"\\parse",
+	"\\password",
+	"\\print",
+	"\\prompt",
+	"\\pset",
+	"\\q",
+	"\\qecho",
+	"\\quit",
+	"\\reset",
+	"\\restrict",
+	"\\s",
+	"\\sendpipeline",
+	"\\set",
+	"\\setenv",
+	"\\sf",
+	"\\startpipeline",
+	"\\sv",
+	"\\syncpipeline",
+	"\\t",
+	"\\T",
+	"\\timing",
+	"\\unrestrict",
+	"\\unset",
+	"\\w",
+	"\\warn",
+	"\\watch",
+	"\\write",
+	"\\x",
+	"\\z",
+	"\\!",
+	"\\?"
 ];
 /** Top-level SQL statement keywords. */
-export const SQL_TOP_KEYWORDS = [
-    "ABORT",
-    "ALTER",
-    "ANALYZE",
-    "BEGIN",
-    "CALL",
-    "CHECKPOINT",
-    "CLOSE",
-    "CLUSTER",
-    "COMMENT",
-    "COMMIT",
-    "COPY",
-    "CREATE",
-    "DEALLOCATE",
-    "DECLARE",
-    "DELETE FROM",
-    "DISCARD",
-    "DO",
-    "DROP",
-    "END",
-    "EXECUTE",
-    "EXPLAIN",
-    "FETCH",
-    "GRANT",
-    "IMPORT",
-    "INSERT INTO",
-    "LISTEN",
-    "LOAD",
-    "LOCK",
-    "MERGE",
-    "MOVE",
-    "NOTIFY",
-    "PREPARE",
-    "REASSIGN",
-    "REFRESH MATERIALIZED VIEW",
-    "REINDEX",
-    "RELEASE",
-    "RESET",
-    "REVOKE",
-    "ROLLBACK",
-    "SAVEPOINT",
-    "SECURITY LABEL",
-    "SELECT",
-    "SET",
-    "SHOW",
-    "START TRANSACTION",
-    "TABLE",
-    "TRUNCATE",
-    "UNLISTEN",
-    "UPDATE",
-    "VACUUM",
-    "VALUES",
-    "WITH",
+const SQL_TOP_KEYWORDS = [
+	"ABORT",
+	"ALTER",
+	"ANALYZE",
+	"BEGIN",
+	"CALL",
+	"CHECKPOINT",
+	"CLOSE",
+	"CLUSTER",
+	"COMMENT",
+	"COMMIT",
+	"COPY",
+	"CREATE",
+	"DEALLOCATE",
+	"DECLARE",
+	"DELETE FROM",
+	"DISCARD",
+	"DO",
+	"DROP",
+	"END",
+	"EXECUTE",
+	"EXPLAIN",
+	"FETCH",
+	"GRANT",
+	"IMPORT",
+	"INSERT INTO",
+	"LISTEN",
+	"LOAD",
+	"LOCK",
+	"MERGE",
+	"MOVE",
+	"NOTIFY",
+	"PREPARE",
+	"REASSIGN",
+	"REFRESH MATERIALIZED VIEW",
+	"REINDEX",
+	"RELEASE",
+	"RESET",
+	"REVOKE",
+	"ROLLBACK",
+	"SAVEPOINT",
+	"SECURITY LABEL",
+	"SELECT",
+	"SET",
+	"SHOW",
+	"START TRANSACTION",
+	"TABLE",
+	"TRUNCATE",
+	"UNLISTEN",
+	"UPDATE",
+	"VACUUM",
+	"VALUES",
+	"WITH"
 ];
 /** Keywords accepted after CREATE. */
-export const CREATE_OBJECTS = [
-    "ACCESS METHOD",
-    "AGGREGATE",
-    "CAST",
-    "COLLATION",
-    "CONVERSION",
-    "DATABASE",
-    "DEFAULT PRIVILEGES",
-    "DOMAIN",
-    "EVENT TRIGGER",
-    "EXTENSION",
-    "FOREIGN DATA WRAPPER",
-    "FOREIGN TABLE",
-    "FUNCTION",
-    "GLOBAL",
-    "GROUP",
-    "INDEX",
-    "LANGUAGE",
-    "LOCAL",
-    "MATERIALIZED VIEW",
-    "OPERATOR",
-    "OR REPLACE",
-    "POLICY",
-    "PROCEDURE",
-    "PUBLICATION",
-    "ROLE",
-    "RULE",
-    "SCHEMA",
-    "SEQUENCE",
-    "SERVER",
-    "STATISTICS",
-    "SUBSCRIPTION",
-    "TABLE",
-    "TABLESPACE",
-    "TEMP",
-    "TEMPORARY",
-    "TEXT SEARCH",
-    "TRANSFORM",
-    "TRIGGER",
-    "TYPE",
-    "UNIQUE",
-    "UNLOGGED",
-    "USER",
-    "VIEW",
+const CREATE_OBJECTS = [
+	"ACCESS METHOD",
+	"AGGREGATE",
+	"CAST",
+	"COLLATION",
+	"CONVERSION",
+	"DATABASE",
+	"DEFAULT PRIVILEGES",
+	"DOMAIN",
+	"EVENT TRIGGER",
+	"EXTENSION",
+	"FOREIGN DATA WRAPPER",
+	"FOREIGN TABLE",
+	"FUNCTION",
+	"GLOBAL",
+	"GROUP",
+	"INDEX",
+	"LANGUAGE",
+	"LOCAL",
+	"MATERIALIZED VIEW",
+	"OPERATOR",
+	"OR REPLACE",
+	"POLICY",
+	"PROCEDURE",
+	"PUBLICATION",
+	"ROLE",
+	"RULE",
+	"SCHEMA",
+	"SEQUENCE",
+	"SERVER",
+	"STATISTICS",
+	"SUBSCRIPTION",
+	"TABLE",
+	"TABLESPACE",
+	"TEMP",
+	"TEMPORARY",
+	"TEXT SEARCH",
+	"TRANSFORM",
+	"TRIGGER",
+	"TYPE",
+	"UNIQUE",
+	"UNLOGGED",
+	"USER",
+	"VIEW"
 ];
 /** Keywords accepted after DROP. */
-export const DROP_OBJECTS = [
-    "ACCESS METHOD",
-    "AGGREGATE",
-    "CAST",
-    "COLLATION",
-    "CONVERSION",
-    "DATABASE",
-    "DOMAIN",
-    "EVENT TRIGGER",
-    "EXTENSION",
-    "FOREIGN DATA WRAPPER",
-    "FOREIGN TABLE",
-    "FUNCTION",
-    "GROUP",
-    "INDEX",
-    "LANGUAGE",
-    "MATERIALIZED VIEW",
-    "OPERATOR",
-    "OWNED",
-    "POLICY",
-    "PROCEDURE",
-    "PUBLICATION",
-    "ROLE",
-    "RULE",
-    "SCHEMA",
-    "SEQUENCE",
-    "SERVER",
-    "STATISTICS",
-    "SUBSCRIPTION",
-    "TABLE",
-    "TABLESPACE",
-    "TEXT SEARCH",
-    "TRANSFORM",
-    "TRIGGER",
-    "TYPE",
-    "USER",
-    "VIEW",
+const DROP_OBJECTS = [
+	"ACCESS METHOD",
+	"AGGREGATE",
+	"CAST",
+	"COLLATION",
+	"CONVERSION",
+	"DATABASE",
+	"DOMAIN",
+	"EVENT TRIGGER",
+	"EXTENSION",
+	"FOREIGN DATA WRAPPER",
+	"FOREIGN TABLE",
+	"FUNCTION",
+	"GROUP",
+	"INDEX",
+	"LANGUAGE",
+	"MATERIALIZED VIEW",
+	"OPERATOR",
+	"OWNED",
+	"POLICY",
+	"PROCEDURE",
+	"PUBLICATION",
+	"ROLE",
+	"RULE",
+	"SCHEMA",
+	"SEQUENCE",
+	"SERVER",
+	"STATISTICS",
+	"SUBSCRIPTION",
+	"TABLE",
+	"TABLESPACE",
+	"TEXT SEARCH",
+	"TRANSFORM",
+	"TRIGGER",
+	"TYPE",
+	"USER",
+	"VIEW"
 ];
 /** Keywords accepted after ALTER. */
-export const ALTER_OBJECTS = [
-    "AGGREGATE",
-    "COLLATION",
-    "CONVERSION",
-    "DATABASE",
-    "DEFAULT PRIVILEGES",
-    "DOMAIN",
-    "EVENT TRIGGER",
-    "EXTENSION",
-    "FOREIGN DATA WRAPPER",
-    "FOREIGN TABLE",
-    "FUNCTION",
-    "GROUP",
-    "INDEX",
-    "LANGUAGE",
-    "LARGE OBJECT",
-    "MATERIALIZED VIEW",
-    "OPERATOR",
-    "POLICY",
-    "PROCEDURE",
-    "PUBLICATION",
-    "ROLE",
-    "RULE",
-    "SCHEMA",
-    "SEQUENCE",
-    "SERVER",
-    "STATISTICS",
-    "SUBSCRIPTION",
-    "SYSTEM",
-    "TABLE",
-    "TABLESPACE",
-    "TEXT SEARCH",
-    "TRIGGER",
-    "TYPE",
-    "USER",
-    "VIEW",
+const ALTER_OBJECTS = [
+	"AGGREGATE",
+	"COLLATION",
+	"CONVERSION",
+	"DATABASE",
+	"DEFAULT PRIVILEGES",
+	"DOMAIN",
+	"EVENT TRIGGER",
+	"EXTENSION",
+	"FOREIGN DATA WRAPPER",
+	"FOREIGN TABLE",
+	"FUNCTION",
+	"GROUP",
+	"INDEX",
+	"LANGUAGE",
+	"LARGE OBJECT",
+	"MATERIALIZED VIEW",
+	"OPERATOR",
+	"POLICY",
+	"PROCEDURE",
+	"PUBLICATION",
+	"ROLE",
+	"RULE",
+	"SCHEMA",
+	"SEQUENCE",
+	"SERVER",
+	"STATISTICS",
+	"SUBSCRIPTION",
+	"SYSTEM",
+	"TABLE",
+	"TABLESPACE",
+	"TEXT SEARCH",
+	"TRIGGER",
+	"TYPE",
+	"USER",
+	"VIEW"
 ];
 /** Sub-actions for ALTER TABLE. */
-export const ALTER_TABLE_ACTIONS = [
-    "ADD",
-    "ALTER",
-    "ATTACH PARTITION",
-    "CLUSTER ON",
-    "DETACH PARTITION",
-    "DISABLE",
-    "DROP",
-    "ENABLE",
-    "INHERIT",
-    "NO INHERIT",
-    "OF",
-    "NOT OF",
-    "OWNER TO",
-    "RENAME",
-    "REPLICA IDENTITY",
-    "RESET",
-    "SET",
-    "VALIDATE CONSTRAINT",
+const ALTER_TABLE_ACTIONS = [
+	"ADD",
+	"ALTER",
+	"ATTACH PARTITION",
+	"CLUSTER ON",
+	"DETACH PARTITION",
+	"DISABLE",
+	"DROP",
+	"ENABLE",
+	"INHERIT",
+	"NO INHERIT",
+	"OF",
+	"NOT OF",
+	"OWNER TO",
+	"RENAME",
+	"REPLICA IDENTITY",
+	"RESET",
+	"SET",
+	"VALIDATE CONSTRAINT"
 ];
 /** Continuation after `ALTER TABLE x ADD`. */
-export const ALTER_TABLE_ADD = [
-    "COLUMN",
-    "CONSTRAINT",
-    "CHECK",
-    "FOREIGN KEY",
-    "PRIMARY KEY",
-    "UNIQUE",
-    "EXCLUDE",
+const ALTER_TABLE_ADD = [
+	"COLUMN",
+	"CONSTRAINT",
+	"CHECK",
+	"FOREIGN KEY",
+	"PRIMARY KEY",
+	"UNIQUE",
+	"EXCLUDE"
 ];
 /** Continuation after `ALTER TABLE x ALTER [COLUMN] y`. */
-export const ALTER_TABLE_ALTER_COLUMN = [
-    "ADD GENERATED",
-    "DROP DEFAULT",
-    "DROP EXPRESSION",
-    "DROP IDENTITY",
-    "DROP NOT NULL",
-    "RESET",
-    "RESTART",
-    "SET",
-    "SET DATA TYPE",
-    "SET DEFAULT",
-    "SET EXPRESSION",
-    "SET GENERATED",
-    "SET NOT NULL",
-    "SET STATISTICS",
-    "SET STORAGE",
-    "TYPE",
+const ALTER_TABLE_ALTER_COLUMN = [
+	"ADD GENERATED",
+	"DROP DEFAULT",
+	"DROP EXPRESSION",
+	"DROP IDENTITY",
+	"DROP NOT NULL",
+	"RESET",
+	"RESTART",
+	"SET",
+	"SET DATA TYPE",
+	"SET DEFAULT",
+	"SET EXPRESSION",
+	"SET GENERATED",
+	"SET NOT NULL",
+	"SET STATISTICS",
+	"SET STORAGE",
+	"TYPE"
 ];
 /** Continuation after `ALTER TABLE x DROP`. */
-export const ALTER_TABLE_DROP = [
-    "COLUMN",
-    "CONSTRAINT",
-    "IF EXISTS",
+const ALTER_TABLE_DROP = [
+	"COLUMN",
+	"CONSTRAINT",
+	"IF EXISTS"
 ];
 /** Continuation after `ALTER TABLE x RENAME`. */
-export const ALTER_TABLE_RENAME = [
-    "COLUMN",
-    "CONSTRAINT",
-    "TO",
+const ALTER_TABLE_RENAME = [
+	"COLUMN",
+	"CONSTRAINT",
+	"TO"
 ];
 /** Continuation after `ALTER TABLE x SET`. */
-export const ALTER_TABLE_SET = [
-    "(",
-    "LOGGED",
-    "SCHEMA",
-    "TABLESPACE",
-    "UNLOGGED",
-    "WITHOUT CLUSTER",
-    "WITHOUT OIDS",
+const ALTER_TABLE_SET = [
+	"(",
+	"LOGGED",
+	"SCHEMA",
+	"TABLESPACE",
+	"UNLOGGED",
+	"WITHOUT CLUSTER",
+	"WITHOUT OIDS"
 ];
 /** Continuation after `ALTER TABLE x ENABLE`. */
-export const ALTER_TABLE_ENABLE = [
-    "ALWAYS",
-    "REPLICA",
-    "ROW LEVEL SECURITY",
-    "RULE",
-    "TRIGGER",
+const ALTER_TABLE_ENABLE = [
+	"ALWAYS",
+	"REPLICA",
+	"ROW LEVEL SECURITY",
+	"RULE",
+	"TRIGGER"
 ];
 /** Continuation after `ALTER TABLE x DISABLE`. */
-export const ALTER_TABLE_DISABLE = [
-    "ROW LEVEL SECURITY",
-    "RULE",
-    "TRIGGER",
+const ALTER_TABLE_DISABLE = [
+	"ROW LEVEL SECURITY",
+	"RULE",
+	"TRIGGER"
 ];
 /** Continuation after `ALTER TABLE x REPLICA IDENTITY`. */
-export const ALTER_TABLE_REPLICA_IDENTITY = [
-    "DEFAULT",
-    "FULL",
-    "NOTHING",
-    "USING INDEX",
+const ALTER_TABLE_REPLICA_IDENTITY = [
+	"DEFAULT",
+	"FULL",
+	"NOTHING",
+	"USING INDEX"
 ];
 /** Sub-actions for ALTER VIEW. */
-export const ALTER_VIEW_ACTIONS = [
-    "ALTER",
-    "OWNER TO",
-    "RENAME",
-    "RESET",
-    "SET",
+const ALTER_VIEW_ACTIONS = [
+	"ALTER",
+	"OWNER TO",
+	"RENAME",
+	"RESET",
+	"SET"
 ];
 /** Sub-actions for ALTER MATERIALIZED VIEW. */
-export const ALTER_MATVIEW_ACTIONS = [
-    "ALTER",
-    "CLUSTER ON",
-    "DEPENDS ON EXTENSION",
-    "NO DEPENDS ON EXTENSION",
-    "OWNER TO",
-    "RENAME",
-    "RESET",
-    "SET",
+const ALTER_MATVIEW_ACTIONS = [
+	"ALTER",
+	"CLUSTER ON",
+	"DEPENDS ON EXTENSION",
+	"NO DEPENDS ON EXTENSION",
+	"OWNER TO",
+	"RENAME",
+	"RESET",
+	"SET"
 ];
 /** Sub-actions for ALTER INDEX. */
-export const ALTER_INDEX_ACTIONS = [
-    "ALTER COLUMN",
-    "ATTACH PARTITION",
-    "DEPENDS ON EXTENSION",
-    "NO DEPENDS ON EXTENSION",
-    "OWNER TO",
-    "RENAME",
-    "RESET",
-    "SET",
+const ALTER_INDEX_ACTIONS = [
+	"ALTER COLUMN",
+	"ATTACH PARTITION",
+	"DEPENDS ON EXTENSION",
+	"NO DEPENDS ON EXTENSION",
+	"OWNER TO",
+	"RENAME",
+	"RESET",
+	"SET"
 ];
 /** Sub-actions for ALTER SEQUENCE. */
-export const ALTER_SEQUENCE_ACTIONS = [
-    "AS",
-    "CACHE",
-    "CYCLE",
-    "INCREMENT BY",
-    "MAXVALUE",
-    "MINVALUE",
-    "NO CYCLE",
-    "NO MAXVALUE",
-    "NO MINVALUE",
-    "OWNED BY",
-    "OWNER TO",
-    "RENAME TO",
-    "RESTART",
-    "SET SCHEMA",
-    "START WITH",
+const ALTER_SEQUENCE_ACTIONS = [
+	"AS",
+	"CACHE",
+	"CYCLE",
+	"INCREMENT BY",
+	"MAXVALUE",
+	"MINVALUE",
+	"NO CYCLE",
+	"NO MAXVALUE",
+	"NO MINVALUE",
+	"OWNED BY",
+	"OWNER TO",
+	"RENAME TO",
+	"RESTART",
+	"SET SCHEMA",
+	"START WITH"
 ];
 /** Sub-actions for ALTER FUNCTION / PROCEDURE / ROUTINE. */
-export const ALTER_FUNCTION_ACTIONS = [
-    "CALLED ON NULL INPUT",
-    "COST",
-    "DEPENDS ON EXTENSION",
-    "IMMUTABLE",
-    "LEAKPROOF",
-    "NO DEPENDS ON EXTENSION",
-    "NOT LEAKPROOF",
-    "OWNER TO",
-    "PARALLEL",
-    "RENAME TO",
-    "RESET",
-    "RETURNS NULL ON NULL INPUT",
-    "ROWS",
-    "SECURITY DEFINER",
-    "SECURITY INVOKER",
-    "SET",
-    "SET SCHEMA",
-    "STABLE",
-    "STRICT",
-    "SUPPORT",
-    "VOLATILE",
+const ALTER_FUNCTION_ACTIONS = [
+	"CALLED ON NULL INPUT",
+	"COST",
+	"DEPENDS ON EXTENSION",
+	"IMMUTABLE",
+	"LEAKPROOF",
+	"NO DEPENDS ON EXTENSION",
+	"NOT LEAKPROOF",
+	"OWNER TO",
+	"PARALLEL",
+	"RENAME TO",
+	"RESET",
+	"RETURNS NULL ON NULL INPUT",
+	"ROWS",
+	"SECURITY DEFINER",
+	"SECURITY INVOKER",
+	"SET",
+	"SET SCHEMA",
+	"STABLE",
+	"STRICT",
+	"SUPPORT",
+	"VOLATILE"
 ];
 /** Sub-actions for ALTER TYPE. */
-export const ALTER_TYPE_ACTIONS = [
-    "ADD ATTRIBUTE",
-    "ADD VALUE",
-    "ALTER ATTRIBUTE",
-    "DROP ATTRIBUTE",
-    "OWNER TO",
-    "RENAME",
-    "RENAME ATTRIBUTE",
-    "RENAME VALUE",
-    "SET SCHEMA",
-    "SET",
+const ALTER_TYPE_ACTIONS = [
+	"ADD ATTRIBUTE",
+	"ADD VALUE",
+	"ALTER ATTRIBUTE",
+	"DROP ATTRIBUTE",
+	"OWNER TO",
+	"RENAME",
+	"RENAME ATTRIBUTE",
+	"RENAME VALUE",
+	"SET SCHEMA",
+	"SET"
 ];
 /** Sub-actions for ALTER ROLE / USER. */
-export const ALTER_ROLE_ACTIONS = [
-    "BYPASSRLS",
-    "CONNECTION LIMIT",
-    "CREATEDB",
-    "CREATEROLE",
-    "ENCRYPTED PASSWORD",
-    "IN DATABASE",
-    "INHERIT",
-    "LOGIN",
-    "NOBYPASSRLS",
-    "NOCREATEDB",
-    "NOCREATEROLE",
-    "NOINHERIT",
-    "NOLOGIN",
-    "NOREPLICATION",
-    "NOSUPERUSER",
-    "PASSWORD",
-    "RENAME TO",
-    "REPLICATION",
-    "RESET",
-    "SET",
-    "SUPERUSER",
-    "VALID UNTIL",
-    "WITH",
+const ALTER_ROLE_ACTIONS = [
+	"BYPASSRLS",
+	"CONNECTION LIMIT",
+	"CREATEDB",
+	"CREATEROLE",
+	"ENCRYPTED PASSWORD",
+	"IN DATABASE",
+	"INHERIT",
+	"LOGIN",
+	"NOBYPASSRLS",
+	"NOCREATEDB",
+	"NOCREATEROLE",
+	"NOINHERIT",
+	"NOLOGIN",
+	"NOREPLICATION",
+	"NOSUPERUSER",
+	"PASSWORD",
+	"RENAME TO",
+	"REPLICATION",
+	"RESET",
+	"SET",
+	"SUPERUSER",
+	"VALID UNTIL",
+	"WITH"
 ];
 /** Sub-actions for ALTER DATABASE. */
-export const ALTER_DATABASE_ACTIONS = [
-    "ALLOW_CONNECTIONS",
-    "CONNECTION LIMIT",
-    "IS_TEMPLATE",
-    "OWNER TO",
-    "REFRESH COLLATION VERSION",
-    "RENAME TO",
-    "RESET",
-    "SET",
-    "SET TABLESPACE",
-    "WITH",
+const ALTER_DATABASE_ACTIONS = [
+	"ALLOW_CONNECTIONS",
+	"CONNECTION LIMIT",
+	"IS_TEMPLATE",
+	"OWNER TO",
+	"REFRESH COLLATION VERSION",
+	"RENAME TO",
+	"RESET",
+	"SET",
+	"SET TABLESPACE",
+	"WITH"
 ];
 /** Sub-actions for ALTER SCHEMA. */
-export const ALTER_SCHEMA_ACTIONS = [
-    "OWNER TO",
-    "RENAME TO",
-];
+const ALTER_SCHEMA_ACTIONS = ["OWNER TO", "RENAME TO"];
 /** Sub-actions for ALTER EXTENSION. */
-export const ALTER_EXTENSION_ACTIONS = [
-    "ADD",
-    "DROP",
-    "SET SCHEMA",
-    "UPDATE",
+const ALTER_EXTENSION_ACTIONS = [
+	"ADD",
+	"DROP",
+	"SET SCHEMA",
+	"UPDATE"
 ];
 /** Sub-actions for ALTER POLICY. */
-export const ALTER_POLICY_ACTIONS = ["ON", "RENAME TO"];
+const ALTER_POLICY_ACTIONS = ["ON", "RENAME TO"];
 /** Sub-actions for ALTER PUBLICATION. */
-export const ALTER_PUBLICATION_ACTIONS = [
-    "ADD",
-    "DROP",
-    "OWNER TO",
-    "RENAME TO",
-    "SET",
+const ALTER_PUBLICATION_ACTIONS = [
+	"ADD",
+	"DROP",
+	"OWNER TO",
+	"RENAME TO",
+	"SET"
 ];
 /** Sub-actions for ALTER SUBSCRIPTION. */
-export const ALTER_SUBSCRIPTION_ACTIONS = [
-    "ADD PUBLICATION",
-    "CONNECTION",
-    "DISABLE",
-    "DROP PUBLICATION",
-    "ENABLE",
-    "OWNER TO",
-    "REFRESH PUBLICATION",
-    "RENAME TO",
-    "SET",
-    "SET PUBLICATION",
-    "SKIP",
+const ALTER_SUBSCRIPTION_ACTIONS = [
+	"ADD PUBLICATION",
+	"CONNECTION",
+	"DISABLE",
+	"DROP PUBLICATION",
+	"ENABLE",
+	"OWNER TO",
+	"REFRESH PUBLICATION",
+	"RENAME TO",
+	"SET",
+	"SET PUBLICATION",
+	"SKIP"
 ];
 /** CREATE INDEX top-level options. */
-export const CREATE_INDEX_OPTIONS = [
-    "CONCURRENTLY",
-    "IF NOT EXISTS",
-    "ON",
-    "UNIQUE",
+const CREATE_INDEX_OPTIONS = [
+	"CONCURRENTLY",
+	"IF NOT EXISTS",
+	"ON",
+	"UNIQUE"
 ];
 /** Window frame clauses after `OVER (`. */
-export const WINDOW_FRAME_KEYWORDS = [
-    "GROUPS",
-    "ORDER BY",
-    "PARTITION BY",
-    "RANGE",
-    "ROWS",
+const WINDOW_FRAME_KEYWORDS = [
+	"GROUPS",
+	"ORDER BY",
+	"PARTITION BY",
+	"RANGE",
+	"ROWS"
 ];
 /** Tail keywords that follow a `FROM <table>` clause in a query. */
-export const POST_FROM_KEYWORDS = [
-    "AS",
-    "CROSS JOIN",
-    "EXCEPT",
-    "FETCH",
-    "FOR",
-    "FULL JOIN",
-    "FULL OUTER JOIN",
-    "GROUP BY",
-    "HAVING",
-    "INNER JOIN",
-    "INTERSECT",
-    "JOIN",
-    "LATERAL",
-    "LEFT JOIN",
-    "LEFT OUTER JOIN",
-    "LIMIT",
-    "NATURAL JOIN",
-    "OFFSET",
-    "ON",
-    "ORDER BY",
-    "RIGHT JOIN",
-    "RIGHT OUTER JOIN",
-    "TABLESAMPLE",
-    "UNION",
-    "USING",
-    "WHERE",
-    "WINDOW",
+const POST_FROM_KEYWORDS = [
+	"AS",
+	"CROSS JOIN",
+	"EXCEPT",
+	"FETCH",
+	"FOR",
+	"FULL JOIN",
+	"FULL OUTER JOIN",
+	"GROUP BY",
+	"HAVING",
+	"INNER JOIN",
+	"INTERSECT",
+	"JOIN",
+	"LATERAL",
+	"LEFT JOIN",
+	"LEFT OUTER JOIN",
+	"LIMIT",
+	"NATURAL JOIN",
+	"OFFSET",
+	"ON",
+	"ORDER BY",
+	"RIGHT JOIN",
+	"RIGHT OUTER JOIN",
+	"TABLESAMPLE",
+	"UNION",
+	"USING",
+	"WHERE",
+	"WINDOW"
 ];
 /** Continuations within a WHERE expression. */
-export const WHERE_CONTINUATIONS = [
-    "AND",
-    "BETWEEN",
-    "IN",
-    "IS",
-    "LIKE",
-    "NOT",
-    "OR",
+const WHERE_CONTINUATIONS = [
+	"AND",
+	"BETWEEN",
+	"IN",
+	"IS",
+	"LIKE",
+	"NOT",
+	"OR"
 ];
 /** Boolean-style values used with `\set` for AUTOCOMMIT etc. (extends ON_OFF). */
-export const DATESTYLE_VALUES = [
-    "GERMAN",
-    "ISO",
-    "POSTGRES",
-    "SQL",
+const DATESTYLE_VALUES = [
+	"GERMAN",
+	"ISO",
+	"POSTGRES",
+	"SQL"
 ];
 /** GRANT / REVOKE privileges. */
-export const PRIVILEGE_KEYWORDS = [
-    "ALL",
-    "CREATE",
-    "CONNECT",
-    "DELETE",
-    "EXECUTE",
-    "INSERT",
-    "REFERENCES",
-    "SELECT",
-    "TEMPORARY",
-    "TRIGGER",
-    "TRUNCATE",
-    "UPDATE",
-    "USAGE",
+const PRIVILEGE_KEYWORDS = [
+	"ALL",
+	"CREATE",
+	"CONNECT",
+	"DELETE",
+	"EXECUTE",
+	"INSERT",
+	"REFERENCES",
+	"SELECT",
+	"TEMPORARY",
+	"TRIGGER",
+	"TRUNCATE",
+	"UPDATE",
+	"USAGE"
 ];
 /** Common transaction/savepoint keywords. */
-export const TRANSACTION_KEYWORDS = [
-    "ISOLATION LEVEL",
-    "READ ONLY",
-    "READ WRITE",
-    "TRANSACTION",
+const TRANSACTION_KEYWORDS = [
+	"ISOLATION LEVEL",
+	"READ ONLY",
+	"READ WRITE",
+	"TRANSACTION"
 ];
 /**
- * Built-in scalar type keywords that psql tab-completion mixes in
- * wherever a type name is expected. Mirrors upstream's
- * `Keywords_for_list_of_datatypes` (tab-complete.in.c). The multi-word
- * names disabled under `#ifdef NOT_USED` upstream are intentionally
- * omitted here too — tab completion can't disambiguate across word
- * boundaries.
- */
-export const BUILTIN_DATATYPE_KEYWORDS = [
-    "bigint",
-    "boolean",
-    "character",
-    "double precision",
-    "integer",
-    "real",
-    "smallint",
+* Built-in scalar type keywords that psql tab-completion mixes in
+* wherever a type name is expected. Mirrors upstream's
+* `Keywords_for_list_of_datatypes` (tab-complete.in.c). The multi-word
+* names disabled under `#ifdef NOT_USED` upstream are intentionally
+* omitted here too — tab completion can't disambiguate across word
+* boundaries.
+*/
+const BUILTIN_DATATYPE_KEYWORDS = [
+	"bigint",
+	"boolean",
+	"character",
+	"double precision",
+	"integer",
+	"real",
+	"smallint"
 ];
 /**
- * COPY ... FROM ... WITH ( ... ) option keywords. Mirrors upstream's
- * `Copy_from_options` macro = `Copy_common_options` + the FROM-specific
- * extras (DEFAULT, FORCE_NOT_NULL, FORCE_NULL, FREEZE, LOG_VERBOSITY,
- * ON_ERROR, REJECT_LIMIT).
- */
-export const COPY_FROM_OPTIONS = [
-    "DELIMITER",
-    "ENCODING",
-    "ESCAPE",
-    "FORMAT",
-    "HEADER",
-    "NULL",
-    "QUOTE",
-    "DEFAULT",
-    "FORCE_NOT_NULL",
-    "FORCE_NULL",
-    "FREEZE",
-    "LOG_VERBOSITY",
-    "ON_ERROR",
-    "REJECT_LIMIT",
+* COPY ... FROM ... WITH ( ... ) option keywords. Mirrors upstream's
+* `Copy_from_options` macro = `Copy_common_options` + the FROM-specific
+* extras (DEFAULT, FORCE_NOT_NULL, FORCE_NULL, FREEZE, LOG_VERBOSITY,
+* ON_ERROR, REJECT_LIMIT).
+*/
+const COPY_FROM_OPTIONS = [
+	"DELIMITER",
+	"ENCODING",
+	"ESCAPE",
+	"FORMAT",
+	"HEADER",
+	"NULL",
+	"QUOTE",
+	"DEFAULT",
+	"FORCE_NOT_NULL",
+	"FORCE_NULL",
+	"FREEZE",
+	"LOG_VERBOSITY",
+	"ON_ERROR",
+	"REJECT_LIMIT"
 ];
 /**
- * COPY ... TO ... WITH ( ... ) option keywords. Mirrors upstream's
- * `Copy_to_options` macro = `Copy_common_options` + `FORCE_QUOTE`.
- */
-export const COPY_TO_OPTIONS = [
-    "DELIMITER",
-    "ENCODING",
-    "ESCAPE",
-    "FORMAT",
-    "HEADER",
-    "NULL",
-    "QUOTE",
-    "FORCE_QUOTE",
+* COPY ... TO ... WITH ( ... ) option keywords. Mirrors upstream's
+* `Copy_to_options` macro = `Copy_common_options` + `FORCE_QUOTE`.
+*/
+const COPY_TO_OPTIONS = [
+	"DELIMITER",
+	"ENCODING",
+	"ESCAPE",
+	"FORMAT",
+	"HEADER",
+	"NULL",
+	"QUOTE",
+	"FORCE_QUOTE"
 ];
 /**
- * Apply a case-insensitive prefix filter. Empty `prefix` returns the whole
- * list. The match honours `compCase` — uppercase the candidates when the
- * user is typing in uppercase, etc.
- */
+* Apply a case-insensitive prefix filter. Empty `prefix` returns the whole
+* list. The match honours `compCase` — uppercase the candidates when the
+* user is typing in uppercase, etc.
+*/
 const filterAndCase = (candidates, prefix, settings) => {
-    const lowPrefix = prefix.toLowerCase();
-    const result = [];
-    for (const c of candidates) {
-        if (c.toLowerCase().startsWith(lowPrefix)) {
-            result.push(applyCase(c, prefix, settings));
-        }
-    }
-    return result;
+	const lowPrefix = prefix.toLowerCase();
+	const result = [];
+	for (const c of candidates) if (c.toLowerCase().startsWith(lowPrefix)) result.push(applyCase(c, prefix, settings));
+	return result;
 };
 /**
- * Render a candidate with the case psql would use, based on `COMP_KEYWORD_CASE`:
- *
- *   - lower            → always lowercase, regardless of input.
- *   - upper            → always uppercase, regardless of input.
- *   - preserve-lower   → lowercase by default; uppercase if the user typed
- *                        a fragment containing an UPPERCASE letter.
- *   - preserve-upper   → (default) uppercase by default; lowercase if the
- *                        user typed a fragment containing a lowercase letter.
- *
- * Per psql docs: "preserve-upper, the default, returns the keyword in upper
- * case unless the partial word entered is in lower case". The dichotomy is
- * really "did the user type ANY lowercase letter" (for preserve-upper) and
- * "did the user type ANY uppercase letter" (for preserve-lower) — matching
- * upstream's `pg_str_endswith` / `pg_str_islower` heuristics.
- */
+* Render a candidate with the case psql would use, based on `COMP_KEYWORD_CASE`:
+*
+*   - lower            → always lowercase, regardless of input.
+*   - upper            → always uppercase, regardless of input.
+*   - preserve-lower   → lowercase by default; uppercase if the user typed
+*                        a fragment containing an UPPERCASE letter.
+*   - preserve-upper   → (default) uppercase by default; lowercase if the
+*                        user typed a fragment containing a lowercase letter.
+*
+* Per psql docs: "preserve-upper, the default, returns the keyword in upper
+* case unless the partial word entered is in lower case". The dichotomy is
+* really "did the user type ANY lowercase letter" (for preserve-upper) and
+* "did the user type ANY uppercase letter" (for preserve-lower) — matching
+* upstream's `pg_str_endswith` / `pg_str_islower` heuristics.
+*/
 const applyCase = (candidate, typed, settings) => {
-    // Identifiers (already quoted, starts with ", or already lowercase) are
-    // never re-cased.
-    if (candidate.startsWith('"') || candidate.startsWith("'"))
-        return candidate;
-    // Catalog query results are always quoted-or-lowercase by virtue of
-    // quote_ident; pass them through unchanged.
-    if (containsNonKeywordChar(candidate))
-        return candidate;
-    const mode = settings.compCase;
-    // Mirror upstream `pg_strdup_keyword_case` (tab-complete.c): the case
-    // decision keys off the FIRST character of the user's input, not the
-    // presence of any case anywhere. Empty input (`first` = 0) is treated as
-    // neither lowercase nor alpha, so:
-    //   - preserve-upper → UPPERCASE (default mode; matches vanilla psql 18
-    //     for the `set <name> <TAB><TAB>` → `TO` case, upstream test
-    //     010_tab_completion.pl line 366).
-    //   - preserve-lower → lowercase.
-    // The same rule applies when the first char is a non-letter (digit, `_`,
-    // punctuation) — those preserve the mode's default direction.
-    const first = typed[0] ?? "";
-    const firstIsLower = /[a-z]/.test(first);
-    const firstIsAlpha = /[A-Za-z]/.test(first);
-    const lowerCaseIt = mode === "lower" ||
-        ((mode === "preserve-lower" || mode === "preserve-upper") &&
-            firstIsLower) ||
-        (mode === "preserve-lower" && !firstIsAlpha);
-    if (mode === "upper")
-        return candidate.toUpperCase();
-    return lowerCaseIt ? candidate.toLowerCase() : candidate.toUpperCase();
+	if (candidate.startsWith("\"") || candidate.startsWith("'")) return candidate;
+	if (containsNonKeywordChar(candidate)) return candidate;
+	const mode = settings.compCase;
+	const first = typed[0] ?? "";
+	const firstIsLower = /[a-z]/.test(first);
+	const firstIsAlpha = /[A-Za-z]/.test(first);
+	const lowerCaseIt = mode === "lower" || (mode === "preserve-lower" || mode === "preserve-upper") && firstIsLower || mode === "preserve-lower" && !firstIsAlpha;
+	if (mode === "upper") return candidate.toUpperCase();
+	return lowerCaseIt ? candidate.toLowerCase() : candidate.toUpperCase();
 };
 const containsNonKeywordChar = (s) => /[^A-Za-z0-9 ]/.test(s);
 /**
- * Split a candidate like `pg_catalog.tab_` into [schema, prefix]. Returns
- * `null` if there's no schema qualifier. `schemaWasQuoted` records whether
- * the user wrote the schema in `"..."` form so the caller can decide whether
- * to fold its case in the rendered output.
- */
+* Split a candidate like `pg_catalog.tab_` into [schema, prefix]. Returns
+* `null` if there's no schema qualifier. `schemaWasQuoted` records whether
+* the user wrote the schema in `"..."` form so the caller can decide whether
+* to fold its case in the rendered output.
+*/
 const splitSchemaPrefix = (word) => {
-    const dot = word.indexOf(".");
-    if (dot < 0)
-        return null;
-    // Reject if anything after the dot looks like another dot (we only handle
-    // schema.relation, not catalog.schema.relation).
-    const after = word.slice(dot + 1);
-    if (after.includes("."))
-        return null;
-    // Strip optional quoting on the schema.
-    let schema = word.slice(0, dot);
-    let schemaWasQuoted = false;
-    if (schema.startsWith('"') && schema.endsWith('"')) {
-        schemaWasQuoted = true;
-        schema = schema.slice(1, -1).replace(/""/g, '"');
-    }
-    return { schema, prefix: after, schemaWasQuoted };
+	const dot = word.indexOf(".");
+	if (dot < 0) return null;
+	const after = word.slice(dot + 1);
+	if (after.includes(".")) return null;
+	let schema = word.slice(0, dot);
+	let schemaWasQuoted = false;
+	if (schema.startsWith("\"") && schema.endsWith("\"")) {
+		schemaWasQuoted = true;
+		schema = schema.slice(1, -1).replace(/""/g, "\"");
+	}
+	return {
+		schema,
+		prefix: after,
+		schemaWasQuoted
+	};
 };
 /**
- * Parse a table reference (the `<ref>` slot in
- * `ALTER TABLE <ref> DROP CONSTRAINT y`) from the already-tokenized
- * `prevWords` slice between `ALTER TABLE` and the action keyword.
- *
- * The scanner can produce the reference as 1 or 2 tokens depending on
- * quoting:
- *
- *   - `tab1`            → `["tab1"]`               (bare, case-folded)
- *   - `"tab1"`          → `["\"tab1\""]`           (quoted, exact-case)
- *   - `public.tab1`     → `["public.tab1"]`        (single token, dotted)
- *   - `public."tab1"`   → `["public.\"tab1\""]`    (single token, dotted+quoted)
- *
- * Returns the parsed parts with case-folding applied to UNQUOTED
- * identifiers (matching `pg_strcasecmp` semantics) so the caller can
- * pass them straight to a `WHERE relname = $N` catalog query.
- *
- * Returns `null` when the tokens don't look like a valid reference.
- */
+* Parse a table reference (the `<ref>` slot in
+* `ALTER TABLE <ref> DROP CONSTRAINT y`) from the already-tokenized
+* `prevWords` slice between `ALTER TABLE` and the action keyword.
+*
+* The scanner can produce the reference as 1 or 2 tokens depending on
+* quoting:
+*
+*   - `tab1`            → `["tab1"]`               (bare, case-folded)
+*   - `"tab1"`          → `["\"tab1\""]`           (quoted, exact-case)
+*   - `public.tab1`     → `["public.tab1"]`        (single token, dotted)
+*   - `public."tab1"`   → `["public.\"tab1\""]`    (single token, dotted+quoted)
+*
+* Returns the parsed parts with case-folding applied to UNQUOTED
+* identifiers (matching `pg_strcasecmp` semantics) so the caller can
+* pass them straight to a `WHERE relname = $N` catalog query.
+*
+* Returns `null` when the tokens don't look like a valid reference.
+*/
 const parseTableRef = (refTokens) => {
-    const stripQuote = (s) => {
-        if (s.length >= 2 && s.startsWith('"') && s.endsWith('"')) {
-            return { v: s.slice(1, -1).replace(/""/g, '"'), quoted: true };
-        }
-        return { v: s, quoted: false };
-    };
-    // Two-token form: `public.` + `"tab1"` (our scanner ends the first
-    // token on the dot when the relation half is quoted).
-    if (refTokens.length === 2) {
-        const first = refTokens[0];
-        if (!first.endsWith("."))
-            return null;
-        const s = stripQuote(first.slice(0, -1));
-        const t = stripQuote(refTokens[1]);
-        if (t.v.length === 0)
-            return null;
-        return {
-            schema: s.quoted ? s.v : s.v.toLowerCase(),
-            table: t.quoted ? t.v : t.v.toLowerCase(),
-        };
-    }
-    if (refTokens.length !== 1)
-        return null;
-    const tok = refTokens[0];
-    // Single-token form. Schema-qualified? Find the FIRST dot that isn't
-    // inside `"..."`.
-    let inQuote = false;
-    let dot = -1;
-    for (let i = 0; i < tok.length; i++) {
-        const ch = tok[i];
-        if (ch === '"') {
-            inQuote = !inQuote;
-        }
-        else if (ch === "." && !inQuote) {
-            dot = i;
-            break;
-        }
-    }
-    if (dot >= 0) {
-        const s = stripQuote(tok.slice(0, dot));
-        const t = stripQuote(tok.slice(dot + 1));
-        if (t.v.length === 0)
-            return null;
-        return {
-            schema: s.quoted ? s.v : s.v.toLowerCase(),
-            table: t.quoted ? t.v : t.v.toLowerCase(),
-        };
-    }
-    const t = stripQuote(tok);
-    if (t.v.length === 0)
-        return null;
-    return { schema: null, table: t.quoted ? t.v : t.v.toLowerCase() };
+	const stripQuote = (s) => {
+		if (s.length >= 2 && s.startsWith("\"") && s.endsWith("\"")) return {
+			v: s.slice(1, -1).replace(/""/g, "\""),
+			quoted: true
+		};
+		return {
+			v: s,
+			quoted: false
+		};
+	};
+	if (refTokens.length === 2) {
+		const first = refTokens[0];
+		if (!first.endsWith(".")) return null;
+		const s = stripQuote(first.slice(0, -1));
+		const t = stripQuote(refTokens[1]);
+		if (t.v.length === 0) return null;
+		return {
+			schema: s.quoted ? s.v : s.v.toLowerCase(),
+			table: t.quoted ? t.v : t.v.toLowerCase()
+		};
+	}
+	if (refTokens.length !== 1) return null;
+	const tok = refTokens[0];
+	let inQuote = false;
+	let dot = -1;
+	for (let i = 0; i < tok.length; i++) {
+		const ch = tok[i];
+		if (ch === "\"") inQuote = !inQuote;
+		else if (ch === "." && !inQuote) {
+			dot = i;
+			break;
+		}
+	}
+	if (dot >= 0) {
+		const s = stripQuote(tok.slice(0, dot));
+		const t = stripQuote(tok.slice(dot + 1));
+		if (t.v.length === 0) return null;
+		return {
+			schema: s.quoted ? s.v : s.v.toLowerCase(),
+			table: t.quoted ? t.v : t.v.toLowerCase()
+		};
+	}
+	const t = stripQuote(tok);
+	if (t.v.length === 0) return null;
+	return {
+		schema: null,
+		table: t.quoted ? t.v : t.v.toLowerCase()
+	};
 };
-// ---------------------------------------------------------------------------
-// Entry point.
-// ---------------------------------------------------------------------------
 /**
- * Top-level rule dispatch.
- *
- * `prevWords` are the tokens BEFORE the current (in-progress) word; the
- * current word's leading characters are what we're filtering candidates
- * against.
- */
-export const findCompletions = async (prevWords, currentWord, ctx) => {
-    // Re-read the connection on every call so `\c` is picked up immediately.
-    const conn = ctx.settings.db ?? ctx.conn ?? null;
-    // ----- Variable expansion (`:NAME`, `:'NAME'`, `:"NAME"`, `:{?NAME}`)
-    // takes priority over anything else. The interpolation forms are valid
-    // both inside SQL and inside backslash-command args (`\echo :VERB`),
-    // so this branch fires regardless of `prevWords`.
-    if (currentWord.startsWith(":") && !currentWord.startsWith("::")) {
-        const names = listVarNames(ctx.settings);
-        const lc = (s) => s.toLowerCase();
-        // `:{?NAME}` — test-form (psqlscan_test_variable upstream). The
-        // candidate must close the `}` so the user's literal `:{?VERB`
-        // expands to `:{?VERBOSITY}` in one Tab.
-        if (currentWord.startsWith(":{?")) {
-            const prefix = currentWord.slice(3);
-            const lp = lc(prefix);
-            const cands = names
-                .filter((n) => lc(n).startsWith(lp))
-                .map((n) => ":{?" + n + "}");
-            return { candidates: cands };
-        }
-        // `:'NAME'` / `:"NAME"` — quoted-substitution forms (psqlscan emits
-        // a quoted literal / identifier). Close the matching quote so the
-        // unique-match path appends a trailing space cleanly.
-        if (currentWord.startsWith(":'")) {
-            const prefix = currentWord.slice(2);
-            const lp = lc(prefix);
-            const cands = names
-                .filter((n) => lc(n).startsWith(lp))
-                .map((n) => ":'" + n + "'");
-            return { candidates: cands };
-        }
-        if (currentWord.startsWith(':"')) {
-            const prefix = currentWord.slice(2);
-            const lp = lc(prefix);
-            const cands = names
-                .filter((n) => lc(n).startsWith(lp))
-                .map((n) => ':"' + n + '"');
-            return { candidates: cands };
-        }
-        // Plain `:NAME` — bare substitution.
-        const prefix = currentWord.slice(1);
-        const lp = lc(prefix);
-        const filt = names
-            .filter((n) => lc(n).startsWith(lp))
-            .map((n) => ":" + n);
-        return { candidates: filt };
-    }
-    // ----- Backslash-command name completion.
-    // Trigger: the user is mid-token and the token starts with '\'.
-    if (currentWord.startsWith("\\") && prevWords.length === 0) {
-        return {
-            candidates: BACKSLASH_COMMANDS.filter((c) => c.toLowerCase().startsWith(currentWord.toLowerCase())),
-        };
-    }
-    // ----- Backslash-command argument completion.
-    if (prevWords.length > 0 && prevWords[0].startsWith("\\")) {
-        return await backslashArgRules(prevWords, currentWord, ctx, conn);
-    }
-    // ----- Multi-line SQL: rules that need to see across the line boundary
-    // re-tokenize `queryBuf` and consult the COMBINED token sequence. The
-    // standard single-line `prevWords` view stays untouched so the bulk of
-    // the rule grammar (which is happy to match on the current line alone)
-    // isn't disturbed.
-    //
-    // Upstream's `get_previous_words` pastes `tab_completion_query_buf` in
-    // front of `rl_line_buffer` with a `\n` separator and tokenizes the
-    // whole thing — see tab-complete.in.c ~line 6670. We mirror that, but
-    // gate the cross-line view to specific rules so the existing tail-match
-    // arms keep their familiar (line-local) semantics.
-    const combined = combinedPrevWords(ctx.queryBuf, prevWords);
-    const multiLine = await multiLineSqlRules(combined, prevWords, currentWord, ctx, conn);
-    if (multiLine !== null)
-        return multiLine;
-    // ----- SQL: top-of-statement keyword completion.
-    if (prevWords.length === 0) {
-        return {
-            candidates: filterAndCase(SQL_TOP_KEYWORDS, currentWord, ctx.settings),
-        };
-    }
-    return await sqlRules(prevWords, currentWord, ctx, conn);
+* Top-level rule dispatch.
+*
+* `prevWords` are the tokens BEFORE the current (in-progress) word; the
+* current word's leading characters are what we're filtering candidates
+* against.
+*/
+const findCompletions = async (prevWords, currentWord, ctx) => {
+	const conn = ctx.settings.db ?? ctx.conn ?? null;
+	if (currentWord.startsWith(":") && !currentWord.startsWith("::")) {
+		const names = listVarNames(ctx.settings);
+		const lc = (s) => s.toLowerCase();
+		if (currentWord.startsWith(":{?")) {
+			const lp = lc(currentWord.slice(3));
+			return { candidates: names.filter((n) => lc(n).startsWith(lp)).map((n) => ":{?" + n + "}") };
+		}
+		if (currentWord.startsWith(":'")) {
+			const lp = lc(currentWord.slice(2));
+			return { candidates: names.filter((n) => lc(n).startsWith(lp)).map((n) => ":'" + n + "'") };
+		}
+		if (currentWord.startsWith(":\"")) {
+			const lp = lc(currentWord.slice(2));
+			return { candidates: names.filter((n) => lc(n).startsWith(lp)).map((n) => ":\"" + n + "\"") };
+		}
+		const lp = lc(currentWord.slice(1));
+		return { candidates: names.filter((n) => lc(n).startsWith(lp)).map((n) => ":" + n) };
+	}
+	if (currentWord.startsWith("\\") && prevWords.length === 0) return { candidates: BACKSLASH_COMMANDS.filter((c) => c.toLowerCase().startsWith(currentWord.toLowerCase())) };
+	if (prevWords.length > 0 && prevWords[0].startsWith("\\")) return await backslashArgRules(prevWords, currentWord, ctx, conn);
+	const combined = combinedPrevWords(ctx.queryBuf, prevWords);
+	const multiLine = await multiLineSqlRules(combined, prevWords, currentWord, ctx, conn);
+	if (multiLine !== null) return multiLine;
+	if (prevWords.length === 0) return { candidates: filterAndCase(SQL_TOP_KEYWORDS, currentWord, ctx.settings) };
+	return await sqlRules(prevWords, currentWord, ctx, conn);
 };
 /**
- * Tokenize `queryBuf` and concatenate with the current line's `prevWords`.
- * The result matches what upstream's `get_previous_words` produces for a
- * multi-line statement: tokens from prior lines first, then tokens from the
- * current line up to the cursor.
- *
- * Tokens cross the line boundary harmlessly because our tokenizer treats
- * `\n` as whitespace (a separator). Newlines INSIDE a `'...'`/`"..."`
- * literal are absorbed by the quoted-string handling and don't split the
- * literal into two tokens.
- */
+* Tokenize `queryBuf` and concatenate with the current line's `prevWords`.
+* The result matches what upstream's `get_previous_words` produces for a
+* multi-line statement: tokens from prior lines first, then tokens from the
+* current line up to the cursor.
+*
+* Tokens cross the line boundary harmlessly because our tokenizer treats
+* `\n` as whitespace (a separator). Newlines INSIDE a `'...'`/`"..."`
+* literal are absorbed by the quoted-string handling and don't split the
+* literal into two tokens.
+*/
 const combinedPrevWords = (queryBuf, prevWords) => {
-    if (queryBuf === undefined || queryBuf.length === 0)
-        return prevWords;
-    const bufTokens = tokenize(queryBuf).map((t) => t.text);
-    return [...bufTokens, ...prevWords];
+	if (queryBuf === void 0 || queryBuf.length === 0) return prevWords;
+	return [...tokenize(queryBuf).map((t) => t.text), ...prevWords];
 };
 /**
- * Rules that fire only when the user is in the middle of a multi-line
- * statement (`queryBuf` non-empty / the combined-token view is longer than
- * the current-line view). Today this covers:
- *
- *   - `ANALYZE (` opened on a previous line — emit the option list.
- *   - `COMMENT ON CONSTRAINT <name> ON <schema>.` continuation —
- *     resolve to the table holding that constraint in `<schema>`.
- *
- * Returns the rule's `RuleResult` when an arm matches, or `null` when the
- * combined-token view doesn't add anything (so the caller continues with
- * the line-local rule grammar).
- */
+* Rules that fire only when the user is in the middle of a multi-line
+* statement (`queryBuf` non-empty / the combined-token view is longer than
+* the current-line view). Today this covers:
+*
+*   - `ANALYZE (` opened on a previous line — emit the option list.
+*   - `COMMENT ON CONSTRAINT <name> ON <schema>.` continuation —
+*     resolve to the table holding that constraint in `<schema>`.
+*
+* Returns the rule's `RuleResult` when an arm matches, or `null` when the
+* combined-token view doesn't add anything (so the caller continues with
+* the line-local rule grammar).
+*/
 const multiLineSqlRules = async (combined, prevWords, currentWord, ctx, conn) => {
-    // Skip if there's no cross-line context to add.
-    if (combined.length === prevWords.length)
-        return null;
-    // ----- ANALYZE ( <prefix> — option list inside the parenthesized form.
-    // Mirrors upstream:
-    //
-    //   else if (HeadMatches("ANALYZE", "(*") &&
-    //            !HeadMatches("ANALYZE", "(*)"))
-    //   {
-    //       if (ends_with(prev_wd, '(') || ends_with(prev_wd, ','))
-    //           COMPLETE_WITH("VERBOSE", "SKIP_LOCKED", "BUFFER_USAGE_LIMIT");
-    //       else if (TailMatches("VERBOSE|SKIP_LOCKED"))
-    //           COMPLETE_WITH("ON", "OFF");
-    //   }
-    //
-    // Our scanner splits `(` and `,` as their own tokens (the C tokenizer
-    // keeps `(verbose` as one word), so `ends_with(prev_wd, '(')` becomes
-    // "previous token IS `(`" and similarly for `,`.
-    if (HeadMatches(combined, ["ANALYZE"]) &&
-        isInsideOpenParen(combined.slice(1))) {
-        const lastTok = combined[combined.length - 1];
-        if (lastTok === "(" || lastTok === ",") {
-            return {
-                candidates: filterAndCase(["VERBOSE", "SKIP_LOCKED", "BUFFER_USAGE_LIMIT"], currentWord, ctx.settings),
-            };
-        }
-        // Inside the option list with a partial option name in the current
-        // word — filter the option list by the prefix.
-        if (currentWord.length > 0 &&
-            (lastTok === undefined || /^[A-Za-z_]+$/.test(currentWord))) {
-            return {
-                candidates: filterAndCase(["VERBOSE", "SKIP_LOCKED", "BUFFER_USAGE_LIMIT"], currentWord, ctx.settings),
-            };
-        }
-        // `VERBOSE` / `SKIP_LOCKED` boolean continuation — ON / OFF.
-        if (TailMatches(combined, ["VERBOSE|SKIP_LOCKED"])) {
-            return {
-                candidates: filterAndCase(["ON", "OFF"], currentWord, ctx.settings),
-            };
-        }
-    }
-    // ----- COMMENT ON CONSTRAINT <name> ON <schema>.<prefix> — resolve to the
-    // table that has `<name>` as a constraint within `<schema>`. Upstream
-    // calls `set_completion_reference(prev2_wd)` (the constraint name) and
-    // runs `Query_for_list_of_tables_for_constraint` with the schema match
-    // baked into the SchemaQuery shape (tab-complete.in.c ~line 3204).
-    //
-    // We allow the rule to fire even when the line-local `prevWords` only
-    // sees the trailing `ON` — the COMBINED tokens carry the
-    // `COMMENT ON CONSTRAINT <name>` prefix from the previous line.
-    if (TailMatches(combined, ["COMMENT", "ON", "CONSTRAINT", MatchAny, "ON"])) {
-        if (!conn)
-            return { candidates: [] };
-        // `combined` ends in `ON`. The constraint name is the token just
-        // before that trailing `ON`. Indexing from the right avoids hard-coding
-        // the queryBuf token count.
-        const constraintNameRaw = combined[combined.length - 2];
-        const constraintName = stripIdentifierQuote(constraintNameRaw);
-        const split = splitSchemaPrefix(currentWord);
-        if (split) {
-            // Schema-qualified: emit tables in `<schema>` that have the named
-            // constraint, with the canonical schema prefix re-attached so the
-            // line ends up looking like `public.tab1`.
-            const rows = await runCatalogQuery(conn, Query_for_list_of_tables_for_constraint_in_schema, split.prefix, [constraintName, split.schema]);
-            const canonicalSchema = split.schemaWasQuoted
-                ? split.schema
-                : split.schema.toLowerCase();
-            return {
-                candidates: rows.map((r) => canonicalSchema + "." + r),
-            };
-        }
-        // Unqualified: list tables that have the constraint, plus the schemas
-        // they live in (with trailing `.` so the user can drill into a schema).
-        const [tables, schemas] = await Promise.all([
-            runCatalogQuery(conn, Query_for_list_of_tables_for_constraint, currentWord, [constraintName]),
-            runCatalogQuery(conn, Query_for_list_of_schemas, currentWord),
-        ]);
-        return { candidates: [...tables, ...schemas.map((s) => s + ".")] };
-    }
-    void conn;
-    return null;
+	if (combined.length === prevWords.length) return null;
+	if (HeadMatches(combined, ["ANALYZE"]) && isInsideOpenParen(combined.slice(1))) {
+		const lastTok = combined[combined.length - 1];
+		if (lastTok === "(" || lastTok === ",") return { candidates: filterAndCase([
+			"VERBOSE",
+			"SKIP_LOCKED",
+			"BUFFER_USAGE_LIMIT"
+		], currentWord, ctx.settings) };
+		if (currentWord.length > 0 && (lastTok === void 0 || /^[A-Za-z_]+$/.test(currentWord))) return { candidates: filterAndCase([
+			"VERBOSE",
+			"SKIP_LOCKED",
+			"BUFFER_USAGE_LIMIT"
+		], currentWord, ctx.settings) };
+		if (TailMatches(combined, ["VERBOSE|SKIP_LOCKED"])) return { candidates: filterAndCase(["ON", "OFF"], currentWord, ctx.settings) };
+	}
+	if (TailMatches(combined, [
+		"COMMENT",
+		"ON",
+		"CONSTRAINT",
+		null,
+		"ON"
+	])) {
+		if (!conn) return { candidates: [] };
+		const constraintNameRaw = combined[combined.length - 2];
+		const constraintName = stripIdentifierQuote(constraintNameRaw);
+		const split = splitSchemaPrefix(currentWord);
+		if (split) {
+			const rows = await runCatalogQuery(conn, Query_for_list_of_tables_for_constraint_in_schema, split.prefix, [constraintName, split.schema]);
+			const canonicalSchema = split.schemaWasQuoted ? split.schema : split.schema.toLowerCase();
+			return { candidates: rows.map((r) => canonicalSchema + "." + r) };
+		}
+		const [tables, schemas] = await Promise.all([runCatalogQuery(conn, Query_for_list_of_tables_for_constraint, currentWord, [constraintName]), runCatalogQuery(conn, Query_for_list_of_schemas, currentWord)]);
+		return { candidates: [...tables, ...schemas.map((s) => s + ".")] };
+	}
+	return null;
 };
 /**
- * Return true when the tokens (after dropping a leading `ANALYZE` keyword)
- * are inside an unclosed parenthesized form — i.e. there's a `(` somewhere
- * and no matching `)` at the trailing position. Mirrors upstream's
- * `HeadMatches("ANALYZE", "(*") && !HeadMatches("ANALYZE", "(*)")`
- * pattern under our split-punctuation tokenizer.
- */
+* Return true when the tokens (after dropping a leading `ANALYZE` keyword)
+* are inside an unclosed parenthesized form — i.e. there's a `(` somewhere
+* and no matching `)` at the trailing position. Mirrors upstream's
+* `HeadMatches("ANALYZE", "(*") && !HeadMatches("ANALYZE", "(*)")`
+* pattern under our split-punctuation tokenizer.
+*/
 const isInsideOpenParen = (tokens) => {
-    let depth = 0;
-    let sawOpen = false;
-    for (const t of tokens) {
-        if (t === "(") {
-            depth++;
-            sawOpen = true;
-        }
-        else if (t === ")") {
-            depth--;
-        }
-    }
-    return sawOpen && depth > 0;
+	let depth = 0;
+	let sawOpen = false;
+	for (const t of tokens) if (t === "(") {
+		depth++;
+		sawOpen = true;
+	} else if (t === ")") depth--;
+	return sawOpen && depth > 0;
 };
 /** Strip surrounding `"..."` quoting from a constraint/identifier token. */
 const stripIdentifierQuote = (raw) => {
-    if (raw === undefined)
-        return "";
-    if (raw.length >= 2 && raw.startsWith('"') && raw.endsWith('"')) {
-        return raw.slice(1, -1).replace(/""/g, '"');
-    }
-    return raw;
+	if (raw === void 0) return "";
+	if (raw.length >= 2 && raw.startsWith("\"") && raw.endsWith("\"")) return raw.slice(1, -1).replace(/""/g, "\"");
+	return raw;
 };
-// ---------------------------------------------------------------------------
-// Backslash arg rules.
-// ---------------------------------------------------------------------------
 const backslashArgRules = async (prevWords, currentWord, ctx, conn) => {
-    const cmd = prevWords[0]; // e.g. '\dt'
-    // \c [DBNAME], \connect [DBNAME]: complete database names.
-    if (cmd === "\\c" || cmd === "\\connect") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_databases, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \dn[+] [schema]
-    if (cmd === "\\dn" || cmd === "\\dn+") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \df, \dfa, \dfn, \dfp, \dft, \dfw, \ef, \sf
-    if (cmd === "\\df" ||
-        cmd === "\\df+" ||
-        cmd === "\\dfa" ||
-        cmd === "\\dfn" ||
-        cmd === "\\dfp" ||
-        cmd === "\\dft" ||
-        cmd === "\\dfw" ||
-        cmd === "\\ef" ||
-        cmd === "\\sf" ||
-        cmd === "\\sf+") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_functions, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \du, \dg → roles.
-    if (cmd === "\\du" ||
-        cmd === "\\dg" ||
-        cmd === "\\du+" ||
-        cmd === "\\dg+") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_roles, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \dx → extensions.
-    if (cmd === "\\dx" || cmd === "\\dx+") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_extensions, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \dL → languages.
-    if (cmd === "\\dL" || cmd === "\\dL+") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_languages, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \dT → types.
-    if (cmd === "\\dT" || cmd === "\\dT+") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_types, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \do → operators.
-    if (cmd === "\\do" ||
-        cmd === "\\do+" ||
-        cmd === "\\doS" ||
-        cmd === "\\doS+") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_operators, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \dC → casts (free-form pattern of "src AS tgt").
-    if (cmd === "\\dC" || cmd === "\\dC+") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_casts, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \dt / \dtv / \d / \dv / \dm / \di / \ds → relations of various kinds.
-    if (cmd === "\\dt" ||
-        cmd === "\\dt+" ||
-        cmd === "\\dtv" ||
-        cmd === "\\d" ||
-        cmd === "\\d+" ||
-        cmd === "\\dE" ||
-        cmd === "\\dE+") {
-        if (prevWords.length === 1 && conn) {
-            return {
-                candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_tables),
-            };
-        }
-        return { candidates: [] };
-    }
-    if (cmd === "\\dv" || cmd === "\\dv+") {
-        if (prevWords.length === 1 && conn) {
-            return {
-                candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_views),
-            };
-        }
-        return { candidates: [] };
-    }
-    if (cmd === "\\dm" || cmd === "\\dm+") {
-        if (prevWords.length === 1 && conn) {
-            return {
-                candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_matviews),
-            };
-        }
-        return { candidates: [] };
-    }
-    if (cmd === "\\di" || cmd === "\\di+") {
-        if (prevWords.length === 1 && conn) {
-            return {
-                candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_indexes),
-            };
-        }
-        return { candidates: [] };
-    }
-    if (cmd === "\\ds" || cmd === "\\ds+") {
-        if (prevWords.length === 1 && conn) {
-            return {
-                candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_sequences),
-            };
-        }
-        return { candidates: [] };
-    }
-    // \l[+] / \list → databases.
-    if (cmd === "\\l" ||
-        cmd === "\\l+" ||
-        cmd === "\\list" ||
-        cmd === "\\list+") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_databases, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // \encoding NAME
-    if (cmd === "\\encoding") {
-        if (prevWords.length === 1) {
-            return { candidates: filterCi(ENCODINGS, currentWord) };
-        }
-        return { candidates: [] };
-    }
-    // \pset OPT [value]
-    if (cmd === "\\pset") {
-        if (prevWords.length === 1) {
-            return { candidates: filterCi(PSET_OPTIONS, currentWord) };
-        }
-        if (prevWords.length === 2) {
-            const values = psetValuesFor(prevWords[1].toLowerCase());
-            if (values)
-                return { candidates: filterCi(values, currentWord) };
-            return { candidates: [] };
-        }
-        return { candidates: [] };
-    }
-    // \set NAME [VALUE]
-    if (cmd === "\\set") {
-        if (prevWords.length === 1) {
-            return {
-                candidates: filterCi(listAllVarNames(ctx.settings), currentWord),
-            };
-        }
-        if (prevWords.length === 2) {
-            const values = variableValuesFor(prevWords[1].toUpperCase());
-            if (values)
-                return { candidates: filterCi(values, currentWord) };
-            return { candidates: [] };
-        }
-        return { candidates: [] };
-    }
-    // \unset NAME — only existing variables.
-    if (cmd === "\\unset") {
-        if (prevWords.length === 1) {
-            return {
-                candidates: filterCi(listVarNames(ctx.settings), currentWord),
-            };
-        }
-        return { candidates: [] };
-    }
-    // \echo / \warn / \qecho — variable expansion only (handled above).
-    // \prompt — variable name argument is the 1st positional.
-    if (cmd === "\\prompt") {
-        if (prevWords.length === 2) {
-            return {
-                candidates: filterCi(listAllVarNames(ctx.settings), currentWord),
-            };
-        }
-        return { candidates: [] };
-    }
-    // \lo_import / \lo_export → filesystem-driven filename completion.
-    // psql parses the path as a backslash-argument literal — no SQL string
-    // quoting required, so we use the unquoted candidate form.
-    if (cmd === "\\lo_import" || cmd === "\\lo_export") {
-        if (prevWords.length === 1) {
-            return { candidates: completeFilenames(currentWord, "none") };
-        }
-        return { candidates: [] };
-    }
-    // \copy <table> [FROM|TO] <path> — once the FROM/TO keyword has been
-    // typed, the next token is a filename (backslash-context, so bare paths
-    // are fine).
-    if (cmd === "\\copy") {
-        // First arg: a table name.
-        if (prevWords.length === 1 && conn) {
-            return {
-                candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_tables),
-            };
-        }
-        // Second arg: the FROM/TO keyword.
-        if (prevWords.length === 2) {
-            return {
-                candidates: filterAndCase(["FROM", "TO"], currentWord, ctx.settings),
-            };
-        }
-        // Third arg (after FROM/TO): the filename.
-        if (prevWords.length >= 3) {
-            const last = prevWords[prevWords.length - 1].toUpperCase();
-            if (last === "FROM" || last === "TO") {
-                return { candidates: completeFilenames(currentWord, "none") };
-            }
-        }
-        return { candidates: [] };
-    }
-    // \drds, \drg → roles (for the first arg).
-    if (cmd === "\\drds" || cmd === "\\drg") {
-        if (prevWords.length === 1 && conn) {
-            const rows = await runCatalogQuery(conn, Query_for_list_of_roles, currentWord);
-            return { candidates: rows };
-        }
-        return { candidates: [] };
-    }
-    // Anything else: no completion.
-    return { candidates: [] };
+	const cmd = prevWords[0];
+	if (cmd === "\\c" || cmd === "\\connect") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_databases, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\dn" || cmd === "\\dn+") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\df" || cmd === "\\df+" || cmd === "\\dfa" || cmd === "\\dfn" || cmd === "\\dfp" || cmd === "\\dft" || cmd === "\\dfw" || cmd === "\\ef" || cmd === "\\sf" || cmd === "\\sf+") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_functions, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\du" || cmd === "\\dg" || cmd === "\\du+" || cmd === "\\dg+") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\dx" || cmd === "\\dx+") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_extensions, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\dL" || cmd === "\\dL+") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_languages, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\dT" || cmd === "\\dT+") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_types, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\do" || cmd === "\\do+" || cmd === "\\doS" || cmd === "\\doS+") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_operators, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\dC" || cmd === "\\dC+") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_casts, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\dt" || cmd === "\\dt+" || cmd === "\\dtv" || cmd === "\\d" || cmd === "\\d+" || cmd === "\\dE" || cmd === "\\dE+") {
+		if (prevWords.length === 1 && conn) return { candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_tables) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\dv" || cmd === "\\dv+") {
+		if (prevWords.length === 1 && conn) return { candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_views) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\dm" || cmd === "\\dm+") {
+		if (prevWords.length === 1 && conn) return { candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_matviews) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\di" || cmd === "\\di+") {
+		if (prevWords.length === 1 && conn) return { candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_indexes) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\ds" || cmd === "\\ds+") {
+		if (prevWords.length === 1 && conn) return { candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_sequences) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\l" || cmd === "\\l+" || cmd === "\\list" || cmd === "\\list+") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_databases, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\encoding") {
+		if (prevWords.length === 1) return { candidates: filterCi(ENCODINGS, currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\pset") {
+		if (prevWords.length === 1) return { candidates: filterCi(PSET_OPTIONS, currentWord) };
+		if (prevWords.length === 2) {
+			const values = psetValuesFor(prevWords[1].toLowerCase());
+			if (values) return { candidates: filterCi(values, currentWord) };
+			return { candidates: [] };
+		}
+		return { candidates: [] };
+	}
+	if (cmd === "\\set") {
+		if (prevWords.length === 1) return { candidates: filterCi(listAllVarNames(ctx.settings), currentWord) };
+		if (prevWords.length === 2) {
+			const values = variableValuesFor(prevWords[1].toUpperCase());
+			if (values) return { candidates: filterCi(values, currentWord) };
+			return { candidates: [] };
+		}
+		return { candidates: [] };
+	}
+	if (cmd === "\\unset") {
+		if (prevWords.length === 1) return { candidates: filterCi(listVarNames(ctx.settings), currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\prompt") {
+		if (prevWords.length === 2) return { candidates: filterCi(listAllVarNames(ctx.settings), currentWord) };
+		return { candidates: [] };
+	}
+	if (cmd === "\\lo_import" || cmd === "\\lo_export") {
+		if (prevWords.length === 1) return { candidates: completeFilenames(currentWord, "none") };
+		return { candidates: [] };
+	}
+	if (cmd === "\\copy") {
+		if (prevWords.length === 1 && conn) return { candidates: await completeSchemaOrRelations(conn, currentWord, Query_for_list_of_tables) };
+		if (prevWords.length === 2) return { candidates: filterAndCase(["FROM", "TO"], currentWord, ctx.settings) };
+		if (prevWords.length >= 3) {
+			const last = prevWords[prevWords.length - 1].toUpperCase();
+			if (last === "FROM" || last === "TO") return { candidates: completeFilenames(currentWord, "none") };
+		}
+		return { candidates: [] };
+	}
+	if (cmd === "\\drds" || cmd === "\\drg") {
+		if (prevWords.length === 1 && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord) };
+		return { candidates: [] };
+	}
+	return { candidates: [] };
 };
-// ---------------------------------------------------------------------------
-// SQL rules.
-// ---------------------------------------------------------------------------
 const sqlRules = async (prevWords, currentWord, ctx, conn) => {
-    // Convenience: most rules want to fall back to a "tables" lookup. We
-    // factor that into a single helper.
-    const completeTables = async (query = Query_for_list_of_tables) => {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await completeSchemaOrRelations(conn, currentWord, query),
-        };
-    };
-    // COPY <table> [FROM|TO] <'path'> — filename completion in the
-    // string-literal context. MUST come before the generic `FROM <prefix>`
-    // rule below, which would otherwise treat the path as a table name.
-    if (isCopyFromOrTo(prevWords)) {
-        return { candidates: completeFilenames(currentWord, "sql") };
-    }
-    // FROM <prefix>: tables/views/matviews. EXCLUDE `REVOKE … FROM <role>`,
-    // which must complete role names — otherwise this generic rule shadows the
-    // REVOKE-roles arm below, making it dead code (review item #26).
-    if (TailMatches(prevWords, ["FROM"]) &&
-        !HeadMatches(prevWords, ["REVOKE"])) {
-        return completeTables(Query_for_list_of_tables_views);
-    }
-    // After FROM x, suggest JOIN/WHERE/etc — handled below.
-    // UPDATE <prefix>: tables.
-    if (TailMatches(prevWords, ["UPDATE"]))
-        return completeTables();
-    // DELETE FROM <prefix>: tables.
-    if (TailMatches(prevWords, ["DELETE", "FROM"]))
-        return completeTables();
-    // INSERT INTO <prefix>: tables. The tokenizer might give us
-    // ['INSERT'] [INTO] or ['INSERT', 'INTO'] depending on whether the user
-    // typed an extra space.
-    if (TailMatches(prevWords, ["INTO"]))
-        return completeTables();
-    // JOIN <prefix>: tables. Most common: SELECT … FROM x JOIN <prefix>.
-    if (TailMatches(prevWords, ["JOIN"])) {
-        return completeTables(Query_for_list_of_tables_views);
-    }
-    // After JOIN x, suggest ON or USING.
-    if (TailMatches(prevWords, ["JOIN", MatchAny])) {
-        return {
-            candidates: filterAndCase(["ON", "USING"], currentWord, ctx.settings),
-        };
-    }
-    // After `FROM table_name <TAB>` (or `FROM table AS alias <TAB>`) — offer
-    // the post-FROM tail keywords. Only fire when the statement starts with
-    // SELECT/INSERT/UPDATE/DELETE (i.e. a SELECT-list-friendly context), so
-    // we don't trample more specific rules like `ALTER TABLE x` or
-    // `INSERT INTO x` which look "FROM-like" structurally.
-    const inSelectContext = HeadMatches(prevWords, ["SELECT"]) ||
-        HeadMatches(prevWords, ["INSERT"]) ||
-        HeadMatches(prevWords, ["UPDATE"]) ||
-        HeadMatches(prevWords, ["DELETE"]) ||
-        HeadMatches(prevWords, ["WITH"]) ||
-        HeadMatches(prevWords, ["EXPLAIN"]);
-    if (inSelectContext &&
-        (TailMatches(prevWords, ["FROM", MatchAny]) ||
-            TailMatches(prevWords, ["FROM", MatchAny, MatchAny]))) {
-        // `FROM x` or `FROM x alias` → post-FROM continuations.
-        return {
-            candidates: filterAndCase(POST_FROM_KEYWORDS, currentWord, ctx.settings),
-        };
-    }
-    // Window-function frame clause: `OVER (` then `<TAB>`. The tokenizer
-    // emits the `(` as its own token, so prevWords ends with '('.
-    if (TailMatches(prevWords, ["OVER", "("])) {
-        return {
-            candidates: filterAndCase(WINDOW_FRAME_KEYWORDS, currentWord, ctx.settings),
-        };
-    }
-    // `OVER <name>` (named window reference) is free-form; no completion.
-    // After a WHERE clause has been started (any `WHERE … <expr> <TAB>`),
-    // suggest boolean continuations. We trigger on the simple case
-    // `WHERE <ident>` and `WHERE … AND/OR <ident>`.
-    if (inSelectContext &&
-        TailMatches(prevWords, ["WHERE", MatchAny]) &&
-        !TailMatches(prevWords, ["WHERE"])) {
-        return {
-            candidates: filterAndCase(WHERE_CONTINUATIONS, currentWord, ctx.settings),
-        };
-    }
-    // ---- ALTER TABLE block ----
-    // Deep ALTER TABLE sub-action continuations must be checked BEFORE the
-    // 3-token fallback `ALTER TABLE x` (which lists generic sub-actions).
-    // The deeper rules use HeadMatches so they survive an arbitrary trailing
-    // option list like `ALTER TABLE foo ADD CONSTRAINT bar CHECK (...)`.
-    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
-        TailMatches(prevWords, ["ADD"])) {
-        return {
-            candidates: filterAndCase(ALTER_TABLE_ADD, currentWord, ctx.settings),
-        };
-    }
-    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
-        TailMatches(prevWords, ["DROP"])) {
-        return {
-            candidates: filterAndCase(ALTER_TABLE_DROP, currentWord, ctx.settings),
-        };
-    }
-    // `ALTER TABLE <ref> DROP CONSTRAINT <prefix>` — constraint names on
-    // the referenced table. Mirrors upstream tab-complete.in.c ~line 1280
-    // (`COMPLETE_WITH_QUERY(Query_for_constraint_of_table)`).
-    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
-        TailMatches(prevWords, ["DROP", "CONSTRAINT"])) {
-        if (!conn)
-            return { candidates: [] };
-        const refTokens = prevWords.slice(2, prevWords.length - 2);
-        const ref = parseTableRef(refTokens);
-        if (!ref)
-            return { candidates: [] };
-        const cands = ref.schema === null
-            ? await runCatalogQuery(conn, Query_for_constraint_of_table, currentWord, [ref.table])
-            : await runCatalogQuery(conn, Query_for_constraint_of_table_in_schema, currentWord, [ref.schema, ref.table]);
-        return { candidates: cands };
-    }
-    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
-        TailMatches(prevWords, ["RENAME"])) {
-        return {
-            candidates: filterAndCase(ALTER_TABLE_RENAME, currentWord, ctx.settings),
-        };
-    }
-    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
-        (TailMatches(prevWords, ["ALTER"]) ||
-            TailMatches(prevWords, ["ALTER", "COLUMN", MatchAny]))) {
-        return {
-            candidates: filterAndCase(ALTER_TABLE_ALTER_COLUMN, currentWord, ctx.settings),
-        };
-    }
-    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
-        TailMatches(prevWords, ["SET"])) {
-        return {
-            candidates: filterAndCase(ALTER_TABLE_SET, currentWord, ctx.settings),
-        };
-    }
-    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
-        TailMatches(prevWords, ["ENABLE"])) {
-        return {
-            candidates: filterAndCase(ALTER_TABLE_ENABLE, currentWord, ctx.settings),
-        };
-    }
-    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
-        TailMatches(prevWords, ["DISABLE"])) {
-        return {
-            candidates: filterAndCase(ALTER_TABLE_DISABLE, currentWord, ctx.settings),
-        };
-    }
-    if (HeadMatches(prevWords, ["ALTER", "TABLE"]) &&
-        TailMatches(prevWords, ["REPLICA", "IDENTITY"])) {
-        return {
-            candidates: filterAndCase(ALTER_TABLE_REPLICA_IDENTITY, currentWord, ctx.settings),
-        };
-    }
-    // ALTER TABLE x — sub-actions (must come AFTER the deep continuations above).
-    if (TailMatches(prevWords, ["ALTER", "TABLE", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_TABLE_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    // ALTER TABLE — table name.
-    if (TailMatches(prevWords, ["ALTER", "TABLE"]))
-        return completeTables();
-    // ---- ALTER VIEW / MATERIALIZED VIEW ----
-    if (TailMatches(prevWords, ["ALTER", "VIEW", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_VIEW_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "VIEW"])) {
-        return completeTables(Query_for_list_of_views);
-    }
-    if (TailMatches(prevWords, ["ALTER", "MATERIALIZED", "VIEW", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_MATVIEW_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "MATERIALIZED", "VIEW"])) {
-        return completeTables(Query_for_list_of_matviews);
-    }
-    // ---- ALTER INDEX ----
-    if (TailMatches(prevWords, ["ALTER", "INDEX", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_INDEX_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "INDEX"])) {
-        return completeTables(Query_for_list_of_indexes);
-    }
-    // ---- ALTER SEQUENCE ----
-    if (TailMatches(prevWords, ["ALTER", "SEQUENCE", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_SEQUENCE_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "SEQUENCE"])) {
-        return completeTables(Query_for_list_of_sequences);
-    }
-    // ---- ALTER FUNCTION / PROCEDURE / ROUTINE ----
-    if (TailMatches(prevWords, [
-        "ALTER",
-        "FUNCTION|PROCEDURE|ROUTINE",
-        MatchAny,
-    ])) {
-        return {
-            candidates: filterAndCase(ALTER_FUNCTION_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "FUNCTION|PROCEDURE|ROUTINE"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_functions, currentWord),
-        };
-    }
-    // ---- ALTER TYPE ----
-    // `ALTER TYPE <enum> RENAME VALUE 'X<TAB>` — enum labels of the named
-    // type, wrapped in single quotes since the user is mid-string-literal.
-    // Mirrors upstream tab-complete.in.c ~line 1480.
-    if (TailMatches(prevWords, [
-        "ALTER",
-        "TYPE",
-        MatchAny,
-        "RENAME",
-        "VALUE",
-    ]) &&
-        currentWord.startsWith("'")) {
-        if (!conn)
-            return { candidates: [] };
-        const typeName = prevWords[prevWords.length - 3].toLowerCase();
-        // Strip the leading quote so the LIKE pattern matches `bar`/`BLACK`
-        // (enumlabel column) rather than `'bar`/`'BLACK`.
-        const labelPrefix = currentWord.slice(1);
-        const cands = await runCatalogQuery(conn, Query_for_list_of_enum_values_quoted, labelPrefix, [typeName]);
-        return { candidates: cands };
-    }
-    if (TailMatches(prevWords, ["ALTER", "TYPE", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_TYPE_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "TYPE"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_types, currentWord),
-        };
-    }
-    // ---- ALTER ROLE / USER / GROUP ----
-    if (TailMatches(prevWords, ["ALTER", "ROLE|USER|GROUP", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_ROLE_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "ROLE|USER|GROUP"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord),
-        };
-    }
-    // ---- ALTER DATABASE ----
-    if (TailMatches(prevWords, ["ALTER", "DATABASE", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_DATABASE_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "DATABASE"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_databases, currentWord),
-        };
-    }
-    // ---- ALTER SCHEMA ----
-    if (TailMatches(prevWords, ["ALTER", "SCHEMA", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_SCHEMA_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "SCHEMA"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord),
-        };
-    }
-    // ---- ALTER EXTENSION ----
-    if (TailMatches(prevWords, ["ALTER", "EXTENSION", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_EXTENSION_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "EXTENSION"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_extensions, currentWord),
-        };
-    }
-    // ---- ALTER POLICY <name> ON <table> ----
-    if (TailMatches(prevWords, ["ALTER", "POLICY", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_POLICY_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (HeadMatches(prevWords, ["ALTER", "POLICY"]) &&
-        TailMatches(prevWords, ["ON"])) {
-        return completeTables();
-    }
-    if (TailMatches(prevWords, ["ALTER", "POLICY"])) {
-        // Free-form policy name.
-        return { candidates: [] };
-    }
-    // ---- ALTER PUBLICATION ----
-    if (TailMatches(prevWords, ["ALTER", "PUBLICATION", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_PUBLICATION_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "PUBLICATION"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_publications, currentWord),
-        };
-    }
-    // ---- ALTER SUBSCRIPTION ----
-    if (TailMatches(prevWords, ["ALTER", "SUBSCRIPTION", MatchAny])) {
-        return {
-            candidates: filterAndCase(ALTER_SUBSCRIPTION_ACTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ALTER", "SUBSCRIPTION"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_subscriptions, currentWord),
-        };
-    }
-    // Bare ALTER — sub-object keywords.
-    if (TailMatches(prevWords, ["ALTER"])) {
-        return {
-            candidates: filterAndCase(ALTER_OBJECTS, currentWord, ctx.settings),
-        };
-    }
-    // DROP TABLE, DROP VIEW, DROP INDEX, ...
-    if (TailMatches(prevWords, ["DROP", "TABLE"]))
-        return completeTables();
-    if (TailMatches(prevWords, ["DROP", "VIEW"])) {
-        return completeTables(Query_for_list_of_views);
-    }
-    if (TailMatches(prevWords, ["DROP", "MATERIALIZED", "VIEW"])) {
-        return completeTables(Query_for_list_of_matviews);
-    }
-    if (TailMatches(prevWords, ["DROP", "INDEX"])) {
-        return completeTables(Query_for_list_of_indexes);
-    }
-    if (TailMatches(prevWords, ["DROP", "SEQUENCE"])) {
-        return completeTables(Query_for_list_of_sequences);
-    }
-    if (TailMatches(prevWords, ["DROP", "TYPE"])) {
-        // Built-in scalar type keywords mirror upstream's
-        // `Keywords_for_list_of_datatypes` attached to the SchemaQuery; psql
-        // mixes them with user-defined types so `DROP TYPE big<TAB>` resolves
-        // to `bigint` even without a matching catalog row.
-        const keywords = filterAndCase(BUILTIN_DATATYPE_KEYWORDS, currentWord, ctx.settings);
-        if (!conn)
-            return { candidates: keywords };
-        const types = await runCatalogQuery(conn, Query_for_list_of_types, currentWord);
-        return { candidates: [...keywords, ...types] };
-    }
-    if (TailMatches(prevWords, ["DROP", "SCHEMA"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["DROP", "EXTENSION"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_extensions, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["DROP", "ROLE|USER|GROUP"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["DROP", "DATABASE"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_databases, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["DROP", "FUNCTION"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_functions, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["DROP", "LANGUAGE"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_languages, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["DROP", "TABLESPACE"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_tablespaces, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["DROP", "PUBLICATION"])) {
-        // Mirrors upstream's `words_after_create` PUBLICATION entry
-        // (VersionedQuery on `Query_for_list_of_publications`). Two-step
-        // completion: `DROP PUBLIC<TAB>` first resolves to `PUBLICATION`
-        // via the static DROP_OBJECTS list (handled below by the bare
-        // `DROP` arm), then `DROP PUBLICATION <TAB>` lists publications.
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_publications, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["DROP", "SUBSCRIPTION"])) {
-        // Same shape as DROP PUBLICATION — paired here for parity with the
-        // ALTER block above.
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_subscriptions, currentWord),
-        };
-    }
-    // Bare DROP — sub-object keywords.
-    if (TailMatches(prevWords, ["DROP"])) {
-        return {
-            candidates: filterAndCase(DROP_OBJECTS, currentWord, ctx.settings),
-        };
-    }
-    // ---- CREATE INDEX deep handling (specific arms BEFORE generic CREATE). ----
-    // CREATE INDEX <TAB> → CONCURRENTLY, IF NOT EXISTS, ON (no name = use ON
-    // directly), or a free-form index name.
-    if (TailMatches(prevWords, ["CREATE", "INDEX"])) {
-        return {
-            candidates: filterAndCase(CREATE_INDEX_OPTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["CREATE", "UNIQUE", "INDEX"])) {
-        return {
-            candidates: filterAndCase(CREATE_INDEX_OPTIONS, currentWord, ctx.settings),
-        };
-    }
-    // CREATE INDEX <name> <TAB> → ON.
-    if (TailMatches(prevWords, ["CREATE", "INDEX", MatchAny]) ||
-        TailMatches(prevWords, ["CREATE", "UNIQUE", "INDEX", MatchAny])) {
-        return { candidates: filterAndCase(["ON"], currentWord, ctx.settings) };
-    }
-    // CREATE INDEX ... ON <TAB> → tables.
-    if (TailMatches(prevWords, ["CREATE", "INDEX", MatchAny, "ON"]) ||
-        TailMatches(prevWords, ["CREATE", "INDEX", "ON"]) ||
-        TailMatches(prevWords, ["CREATE", "UNIQUE", "INDEX", MatchAny, "ON"]) ||
-        TailMatches(prevWords, ["CREATE", "UNIQUE", "INDEX", "ON"])) {
-        return completeTables();
-    }
-    // CREATE INDEX ... ON <table> <TAB> → USING / (.
-    if ((HeadMatches(prevWords, ["CREATE", "INDEX"]) ||
-        HeadMatches(prevWords, ["CREATE", "UNIQUE", "INDEX"])) &&
-        TailMatches(prevWords, ["ON", MatchAny])) {
-        return {
-            candidates: filterAndCase(["USING", "("], currentWord, ctx.settings),
-        };
-    }
-    // CREATE INDEX ... USING <TAB> → access methods.
-    if ((HeadMatches(prevWords, ["CREATE", "INDEX"]) ||
-        HeadMatches(prevWords, ["CREATE", "UNIQUE", "INDEX"])) &&
-        TailMatches(prevWords, ["USING"])) {
-        if (!conn) {
-            // Even without a connection, offer the built-in AMs as a fallback.
-            return {
-                candidates: filterAndCase(["btree", "hash", "gist", "gin", "spgist", "brin"], currentWord, ctx.settings),
-            };
-        }
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_index_access_methods, currentWord),
-        };
-    }
-    // CREATE ... — first sub-object keyword.
-    if (TailMatches(prevWords, ["CREATE"])) {
-        return {
-            candidates: filterAndCase(CREATE_OBJECTS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["CREATE", "TABLE"])) {
-        // Upstream's `words_after_create` fallback (tab-complete.in.c
-        // ~lines 2062-2082) runs `Query_for_list_of_tables` when the
-        // word immediately before the cursor is `TABLE`. The intent is to
-        // surface existing table names as a HINT — the user can pick a
-        // similar name as a starting point. The completion is non-binding;
-        // psql doesn't actually insert one of these on a single Tab if
-        // the prefix is ambiguous, but the listing on Tab-Tab matches
-        // upstream's `qr/mytab123 +mytab246/`.
-        return completeTables();
-    }
-    // Inside CREATE TABLE column-list parens: `<col_name> <TAB>` → types.
-    if (HeadMatches(prevWords, ["CREATE", "TABLE"]) &&
-        TailMatches(prevWords, ["(|,", MatchAny])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_datatypes, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["CREATE", "OR", "REPLACE"])) {
-        return {
-            candidates: filterAndCase([
-                "FUNCTION",
-                "PROCEDURE",
-                "VIEW",
-                "TRIGGER",
-                "AGGREGATE",
-                "TRANSFORM",
-            ], currentWord, ctx.settings),
-        };
-    }
-    // TRUNCATE [TABLE] x
-    if (TailMatches(prevWords, ["TRUNCATE"])) {
-        return {
-            candidates: [
-                ...filterAndCase(["TABLE", "ONLY"], currentWord, ctx.settings),
-                ...(await tableCandidates(conn, currentWord)),
-            ],
-        };
-    }
-    if (TailMatches(prevWords, ["TRUNCATE", "TABLE"]))
-        return completeTables();
-    if (TailMatches(prevWords, ["TRUNCATE", "ONLY"]))
-        return completeTables();
-    // COPY ... FROM <sth> WITH ( — option keywords inside the WITH
-    // parenthesised list. The tokenizer splits `(` and `,` into their
-    // own tokens so the tail looks like `[... WITH (]` for the first
-    // option and `[..., WITH, (, opt, ,]` for subsequent ones. Two
-    // arms: one for FROM (which adds DEFAULT, FORCE_NOT_NULL, etc.)
-    // and one for TO (which adds FORCE_QUOTE only). Mirrors upstream
-    // tab-complete.in.c ~3309-3315 (`Copy_from_options` /
-    // `Copy_to_options`). The `HeadMatches` guard restricts the rule
-    // to a real COPY statement so the generic `(`/`,` pattern doesn't
-    // fire inside CREATE TABLE / SELECT lists.
-    if (HeadMatches(prevWords, ["COPY|\\copy"]) &&
-        HeadMatches(prevWords, [MatchAny, MatchAny, "FROM"]) &&
-        (TailMatches(prevWords, ["("]) || TailMatches(prevWords, [","]))) {
-        return {
-            candidates: filterAndCase(COPY_FROM_OPTIONS, currentWord, ctx.settings),
-        };
-    }
-    if (HeadMatches(prevWords, ["COPY|\\copy"]) &&
-        HeadMatches(prevWords, [MatchAny, MatchAny, "TO"]) &&
-        (TailMatches(prevWords, ["("]) || TailMatches(prevWords, [","]))) {
-        return {
-            candidates: filterAndCase(COPY_TO_OPTIONS, currentWord, ctx.settings),
-        };
-    }
-    // COPY x → tables. (The `COPY x FROM/TO <path>` filename completion is
-    // handled by the early `isCopyFromOrTo` check at the top of this
-    // function so it wins over the generic `FROM <prefix>` table rule.)
-    if (TailMatches(prevWords, ["COPY"]))
-        return completeTables();
-    if (TailMatches(prevWords, ["COPY", MatchAny])) {
-        return {
-            candidates: filterAndCase(["FROM", "TO"], currentWord, ctx.settings),
-        };
-    }
-    // ANALYZE x → tables (optional VERBOSE first).
-    if (TailMatches(prevWords, ["ANALYZE"]) ||
-        TailMatches(prevWords, ["ANALYZE", "VERBOSE"])) {
-        return completeTables();
-    }
-    // VACUUM x → tables.
-    if (TailMatches(prevWords, ["VACUUM"]) ||
-        TailMatches(prevWords, ["VACUUM", "VERBOSE"])) {
-        return completeTables();
-    }
-    if (TailMatches(prevWords, ["VACUUM", "FULL"]))
-        return completeTables();
-    if (TailMatches(prevWords, ["VACUUM", "ANALYZE"]))
-        return completeTables();
-    // REINDEX [TABLE|INDEX|SCHEMA|DATABASE] x
-    if (TailMatches(prevWords, ["REINDEX"])) {
-        return {
-            candidates: filterAndCase([
-                "TABLE",
-                "INDEX",
-                "SCHEMA",
-                "DATABASE",
-                "SYSTEM",
-                "CONCURRENTLY",
-            ], currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["REINDEX", "TABLE"]))
-        return completeTables();
-    if (TailMatches(prevWords, ["REINDEX", "INDEX"])) {
-        return completeTables(Query_for_list_of_indexes);
-    }
-    if (TailMatches(prevWords, ["REINDEX", "SCHEMA"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["REINDEX", "DATABASE"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_databases, currentWord),
-        };
-    }
-    // GRANT … ON … TO …
-    if (TailMatches(prevWords, ["GRANT"]) ||
-        TailMatches(prevWords, ["REVOKE"])) {
-        return {
-            candidates: filterAndCase(PRIVILEGE_KEYWORDS, currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["ON"])) {
-        // Could be either GRANT/REVOKE … ON or CREATE INDEX … ON. We try
-        // tables; if the prior keyword set is CREATE INDEX the rule above
-        // already short-circuited.
-        return completeTables();
-    }
-    if (TailMatches(prevWords, ["TO"])) {
-        if (HeadMatches(prevWords, ["GRANT"]) && conn) {
-            return {
-                candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord),
-            };
-        }
-    }
-    if (TailMatches(prevWords, ["FROM"]) &&
-        HeadMatches(prevWords, ["REVOKE"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord),
-        };
-    }
-    // LOCK [TABLE] x
-    if (TailMatches(prevWords, ["LOCK"])) {
-        return {
-            candidates: [
-                ...filterAndCase(["TABLE"], currentWord, ctx.settings),
-                ...(await tableCandidates(conn, currentWord)),
-            ],
-        };
-    }
-    if (TailMatches(prevWords, ["LOCK", "TABLE"]))
-        return completeTables();
-    // SET search_path, SET ROLE, SET SCHEMA, etc.
-    if (TailMatches(prevWords, ["SET", "ROLE"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["SET", "SCHEMA"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord),
-        };
-    }
-    if (TailMatches(prevWords, ["SET", "SESSION"])) {
-        return {
-            candidates: filterAndCase(["AUTHORIZATION", "CHARACTERISTICS AS TRANSACTION"], currentWord, ctx.settings),
-        };
-    }
-    if (TailMatches(prevWords, ["SET", "TRANSACTION"])) {
-        return {
-            candidates: filterAndCase(["ISOLATION LEVEL", "READ ONLY", "READ WRITE", "DEFERRABLE"], currentWord, ctx.settings),
-        };
-    }
-    // `SET <name> TO|= <TAB>` — for DateStyle we can suggest the formats.
-    if (TailMatches(prevWords, ["SET", "DateStyle", "TO|="]) ||
-        TailMatches(prevWords, ["SET", "DATESTYLE", "TO|="]) ||
-        TailMatches(prevWords, ["SET", "datestyle", "TO|="])) {
-        return {
-            candidates: filterAndCase(DATESTYLE_VALUES, currentWord, ctx.settings),
-        };
-    }
-    // `SET timezone TO <prefix>` — names from pg_timezone_names. Two
-    // variants depending on whether the user has opened a single quote:
-    //   - `SET timezone TO am<TAB>`  → user typed an unquoted prefix; we
-    //     respond with `'America/'`-style quoted candidates so the next
-    //     keystroke continues inside the string literal. The
-    //     `Query_for_list_of_timezone_names_quoted_out` template matches
-    //     LIKE against the unquoted name and returns `quote_literal(name)`.
-    //   - `SET timezone TO 'America/New_<TAB>` → user is mid-literal;
-    //     `Query_for_list_of_timezone_names_quoted_in` matches the LIKE
-    //     pattern against the quoted form so the partial `'America/New_`
-    //     resolves correctly.
-    // Mirrors upstream tab-complete.in.c ~line 4530.
-    if (TailMatches(prevWords, ["SET", "timezone", "TO|="]) ||
-        TailMatches(prevWords, ["SET", "TIMEZONE", "TO|="]) ||
-        TailMatches(prevWords, ["SET", "TimeZone", "TO|="])) {
-        if (!conn)
-            return { candidates: [] };
-        const query = currentWord.startsWith("'")
-            ? Query_for_list_of_timezone_names_quoted_in
-            : Query_for_list_of_timezone_names_quoted_out;
-        const cands = await runCatalogQuery(conn, query, currentWord);
-        return { candidates: cands };
-    }
-    // `SET <name> TO|= <prefix>` for any enum-typed GUC — emit the legal
-    // values from `pg_settings.enumvals`. Mirrors upstream `tab-complete.in.c`
-    // `Query_for_values_of_enum_GUC`. Enum-typed GUCs (intervalstyle,
-    // bytea_output, synchronous_commit, plpgsql.variable_conflict, …) get
-    // value completion; non-enum GUCs return an empty rowset (no candidates)
-    // — matching upstream, which also emits nothing for unknown GUCs once a
-    // value position is reached.
-    if (TailMatches(prevWords, ["SET", MatchAny, "TO|="])) {
-        if (!conn)
-            return { candidates: [] };
-        // Walk back to the GUC name (the word before TO/=).
-        const gucName = prevWords[prevWords.length - 2];
-        const cands = await runCatalogQuery(conn, Query_for_values_of_enum_GUC, currentWord, [gucName]);
-        return { candidates: cands };
-    }
-    // `SET <name> <TAB>` (no operator yet) → TO.
-    // Upstream tab-complete.in.c uses `COMPLETE_WITH("TO")` here even
-    // though `SET <name> = <value>` is valid syntax — the goal is a
-    // single unique completion so `set foo<tab><tab>` resolves to
-    // `set foo TO ` rather than listing two near-synonymous separators.
-    // Verified against vanilla psql 18 + upstream test line 366.
-    if (TailMatches(prevWords, ["SET", MatchAny])) {
-        return {
-            candidates: filterAndCase(["TO"], currentWord, ctx.settings),
-        };
-    }
-    // Bare SET <TAB>: GUC name OR top-level SET sub-keywords (ROLE, SCHEMA, …).
-    if (TailMatches(prevWords, ["SET"])) {
-        const staticKw = filterAndCase([
-            "CONSTRAINTS",
-            "LOCAL",
-            "ROLE",
-            "SCHEMA",
-            "SESSION",
-            "TIME ZONE",
-            "TRANSACTION",
-        ], currentWord, ctx.settings);
-        if (!conn)
-            return { candidates: staticKw };
-        const guc = await runCatalogQuery(conn, Query_for_list_of_set_vars, currentWord);
-        return { candidates: [...staticKw, ...guc] };
-    }
-    // SHOW <TAB> — ALL keyword plus the live GUC list.
-    if (TailMatches(prevWords, ["SHOW"])) {
-        const staticKw = filterAndCase(["ALL"], currentWord, ctx.settings);
-        if (!conn) {
-            return {
-                candidates: [
-                    ...staticKw,
-                    ...filterAndCase([
-                        "search_path",
-                        "role",
-                        "session_authorization",
-                        "transaction_isolation",
-                        "client_encoding",
-                        "server_encoding",
-                        "server_version",
-                        "timezone",
-                    ], currentWord, ctx.settings),
-                ],
-            };
-        }
-        const guc = await runCatalogQuery(conn, Query_for_list_of_set_vars, currentWord);
-        return { candidates: [...staticKw, ...guc] };
-    }
-    // RESET <TAB> — ALL or the live GUC list.
-    if (TailMatches(prevWords, ["RESET"])) {
-        const staticKw = filterAndCase(["ALL", "SESSION AUTHORIZATION", "ROLE"], currentWord, ctx.settings);
-        if (!conn)
-            return { candidates: staticKw };
-        const guc = await runCatalogQuery(conn, Query_for_list_of_set_vars, currentWord);
-        return { candidates: [...staticKw, ...guc] };
-    }
-    // START / BEGIN [TRANSACTION] …
-    if (TailMatches(prevWords, ["BEGIN"]) ||
-        TailMatches(prevWords, ["START"])) {
-        return {
-            candidates: filterAndCase(TRANSACTION_KEYWORDS, currentWord, ctx.settings),
-        };
-    }
-    // COMMIT / ROLLBACK / RELEASE / SAVEPOINT - small completions
-    if (TailMatches(prevWords, ["ROLLBACK"])) {
-        return {
-            candidates: filterAndCase(["TO SAVEPOINT", "TRANSACTION", "AND CHAIN", "AND NO CHAIN"], currentWord, ctx.settings),
-        };
-    }
-    // EXPLAIN … — pass through to SELECT-/INSERT-/UPDATE-style rules by
-    // letting subsequent words drive completion. For the first word after
-    // EXPLAIN, offer the options + statement keywords.
-    if (TailMatches(prevWords, ["EXPLAIN"])) {
-        return {
-            candidates: filterAndCase([
-                "ANALYZE",
-                "VERBOSE",
-                "SELECT",
-                "INSERT INTO",
-                "UPDATE",
-                "DELETE FROM",
-                "(",
-            ], currentWord, ctx.settings),
-        };
-    }
-    // DECLARE … CURSOR FOR …
-    if (TailMatches(prevWords, ["DECLARE"])) {
-        return { candidates: [] };
-    }
-    // CALL / DO — no completion beyond keywords (procedure args / language).
-    if (TailMatches(prevWords, ["CALL"])) {
-        if (!conn)
-            return { candidates: [] };
-        return {
-            candidates: await runCatalogQuery(conn, Query_for_list_of_functions, currentWord),
-        };
-    }
-    // After SELECT — offer FROM / common functions.
-    if (TailMatches(prevWords, ["SELECT"])) {
-        // The next word can be anything (column list); offer DISTINCT/ALL/* as a
-        // small hint set.
-        return {
-            candidates: filterAndCase([
-                "DISTINCT",
-                "ALL",
-                "*",
-                "CURRENT_DATE",
-                "CURRENT_TIME",
-                "CURRENT_TIMESTAMP",
-                "CURRENT_USER",
-                "NULL",
-                "TRUE",
-                "FALSE",
-            ], currentWord, ctx.settings),
-        };
-    }
-    // Trailing-keyword fallthrough: WHERE, ORDER BY, GROUP BY, LIMIT etc.
-    if (TailMatches(prevWords, ["SELECT", "*"])) {
-        return {
-            candidates: filterAndCase(["FROM"], currentWord, ctx.settings),
-        };
-    }
-    // No specific rule fired.
-    return { candidates: [] };
+	const completeTables = async (query = Query_for_list_of_tables) => {
+		if (!conn) return { candidates: [] };
+		return { candidates: await completeSchemaOrRelations(conn, currentWord, query) };
+	};
+	if (isCopyFromOrTo(prevWords)) return { candidates: completeFilenames(currentWord, "sql") };
+	if (TailMatches(prevWords, ["FROM"]) && !HeadMatches(prevWords, ["REVOKE"])) return completeTables(Query_for_list_of_tables_views);
+	if (TailMatches(prevWords, ["UPDATE"])) return completeTables();
+	if (TailMatches(prevWords, ["DELETE", "FROM"])) return completeTables();
+	if (TailMatches(prevWords, ["INTO"])) return completeTables();
+	if (TailMatches(prevWords, ["JOIN"])) return completeTables(Query_for_list_of_tables_views);
+	if (TailMatches(prevWords, ["JOIN", null])) return { candidates: filterAndCase(["ON", "USING"], currentWord, ctx.settings) };
+	const inSelectContext = HeadMatches(prevWords, ["SELECT"]) || HeadMatches(prevWords, ["INSERT"]) || HeadMatches(prevWords, ["UPDATE"]) || HeadMatches(prevWords, ["DELETE"]) || HeadMatches(prevWords, ["WITH"]) || HeadMatches(prevWords, ["EXPLAIN"]);
+	if (inSelectContext && (TailMatches(prevWords, ["FROM", null]) || TailMatches(prevWords, [
+		"FROM",
+		null,
+		null
+	]))) return { candidates: filterAndCase(POST_FROM_KEYWORDS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["OVER", "("])) return { candidates: filterAndCase(WINDOW_FRAME_KEYWORDS, currentWord, ctx.settings) };
+	if (inSelectContext && TailMatches(prevWords, ["WHERE", null]) && !TailMatches(prevWords, ["WHERE"])) return { candidates: filterAndCase(WHERE_CONTINUATIONS, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["ALTER", "TABLE"]) && TailMatches(prevWords, ["ADD"])) return { candidates: filterAndCase(ALTER_TABLE_ADD, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["ALTER", "TABLE"]) && TailMatches(prevWords, ["DROP"])) return { candidates: filterAndCase(ALTER_TABLE_DROP, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["ALTER", "TABLE"]) && TailMatches(prevWords, ["DROP", "CONSTRAINT"])) {
+		if (!conn) return { candidates: [] };
+		const refTokens = prevWords.slice(2, prevWords.length - 2);
+		const ref = parseTableRef(refTokens);
+		if (!ref) return { candidates: [] };
+		return { candidates: ref.schema === null ? await runCatalogQuery(conn, Query_for_constraint_of_table, currentWord, [ref.table]) : await runCatalogQuery(conn, Query_for_constraint_of_table_in_schema, currentWord, [ref.schema, ref.table]) };
+	}
+	if (HeadMatches(prevWords, ["ALTER", "TABLE"]) && TailMatches(prevWords, ["RENAME"])) return { candidates: filterAndCase(ALTER_TABLE_RENAME, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["ALTER", "TABLE"]) && (TailMatches(prevWords, ["ALTER"]) || TailMatches(prevWords, [
+		"ALTER",
+		"COLUMN",
+		null
+	]))) return { candidates: filterAndCase(ALTER_TABLE_ALTER_COLUMN, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["ALTER", "TABLE"]) && TailMatches(prevWords, ["SET"])) return { candidates: filterAndCase(ALTER_TABLE_SET, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["ALTER", "TABLE"]) && TailMatches(prevWords, ["ENABLE"])) return { candidates: filterAndCase(ALTER_TABLE_ENABLE, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["ALTER", "TABLE"]) && TailMatches(prevWords, ["DISABLE"])) return { candidates: filterAndCase(ALTER_TABLE_DISABLE, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["ALTER", "TABLE"]) && TailMatches(prevWords, ["REPLICA", "IDENTITY"])) return { candidates: filterAndCase(ALTER_TABLE_REPLICA_IDENTITY, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"TABLE",
+		null
+	])) return { candidates: filterAndCase(ALTER_TABLE_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "TABLE"])) return completeTables();
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"VIEW",
+		null
+	])) return { candidates: filterAndCase(ALTER_VIEW_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "VIEW"])) return completeTables(Query_for_list_of_views);
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"MATERIALIZED",
+		"VIEW",
+		null
+	])) return { candidates: filterAndCase(ALTER_MATVIEW_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"MATERIALIZED",
+		"VIEW"
+	])) return completeTables(Query_for_list_of_matviews);
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"INDEX",
+		null
+	])) return { candidates: filterAndCase(ALTER_INDEX_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "INDEX"])) return completeTables(Query_for_list_of_indexes);
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"SEQUENCE",
+		null
+	])) return { candidates: filterAndCase(ALTER_SEQUENCE_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "SEQUENCE"])) return completeTables(Query_for_list_of_sequences);
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"FUNCTION|PROCEDURE|ROUTINE",
+		null
+	])) return { candidates: filterAndCase(ALTER_FUNCTION_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "FUNCTION|PROCEDURE|ROUTINE"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_functions, currentWord) };
+	}
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"TYPE",
+		null,
+		"RENAME",
+		"VALUE"
+	]) && currentWord.startsWith("'")) {
+		if (!conn) return { candidates: [] };
+		const typeName = prevWords[prevWords.length - 3].toLowerCase();
+		const labelPrefix = currentWord.slice(1);
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_enum_values_quoted, labelPrefix, [typeName]) };
+	}
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"TYPE",
+		null
+	])) return { candidates: filterAndCase(ALTER_TYPE_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "TYPE"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_types, currentWord) };
+	}
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"ROLE|USER|GROUP",
+		null
+	])) return { candidates: filterAndCase(ALTER_ROLE_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "ROLE|USER|GROUP"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord) };
+	}
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"DATABASE",
+		null
+	])) return { candidates: filterAndCase(ALTER_DATABASE_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "DATABASE"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_databases, currentWord) };
+	}
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"SCHEMA",
+		null
+	])) return { candidates: filterAndCase(ALTER_SCHEMA_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "SCHEMA"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord) };
+	}
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"EXTENSION",
+		null
+	])) return { candidates: filterAndCase(ALTER_EXTENSION_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "EXTENSION"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_extensions, currentWord) };
+	}
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"POLICY",
+		null
+	])) return { candidates: filterAndCase(ALTER_POLICY_ACTIONS, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["ALTER", "POLICY"]) && TailMatches(prevWords, ["ON"])) return completeTables();
+	if (TailMatches(prevWords, ["ALTER", "POLICY"])) return { candidates: [] };
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"PUBLICATION",
+		null
+	])) return { candidates: filterAndCase(ALTER_PUBLICATION_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "PUBLICATION"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_publications, currentWord) };
+	}
+	if (TailMatches(prevWords, [
+		"ALTER",
+		"SUBSCRIPTION",
+		null
+	])) return { candidates: filterAndCase(ALTER_SUBSCRIPTION_ACTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ALTER", "SUBSCRIPTION"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_subscriptions, currentWord) };
+	}
+	if (TailMatches(prevWords, ["ALTER"])) return { candidates: filterAndCase(ALTER_OBJECTS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["DROP", "TABLE"])) return completeTables();
+	if (TailMatches(prevWords, ["DROP", "VIEW"])) return completeTables(Query_for_list_of_views);
+	if (TailMatches(prevWords, [
+		"DROP",
+		"MATERIALIZED",
+		"VIEW"
+	])) return completeTables(Query_for_list_of_matviews);
+	if (TailMatches(prevWords, ["DROP", "INDEX"])) return completeTables(Query_for_list_of_indexes);
+	if (TailMatches(prevWords, ["DROP", "SEQUENCE"])) return completeTables(Query_for_list_of_sequences);
+	if (TailMatches(prevWords, ["DROP", "TYPE"])) {
+		const keywords = filterAndCase(BUILTIN_DATATYPE_KEYWORDS, currentWord, ctx.settings);
+		if (!conn) return { candidates: keywords };
+		const types = await runCatalogQuery(conn, Query_for_list_of_types, currentWord);
+		return { candidates: [...keywords, ...types] };
+	}
+	if (TailMatches(prevWords, ["DROP", "SCHEMA"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord) };
+	}
+	if (TailMatches(prevWords, ["DROP", "EXTENSION"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_extensions, currentWord) };
+	}
+	if (TailMatches(prevWords, ["DROP", "ROLE|USER|GROUP"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord) };
+	}
+	if (TailMatches(prevWords, ["DROP", "DATABASE"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_databases, currentWord) };
+	}
+	if (TailMatches(prevWords, ["DROP", "FUNCTION"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_functions, currentWord) };
+	}
+	if (TailMatches(prevWords, ["DROP", "LANGUAGE"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_languages, currentWord) };
+	}
+	if (TailMatches(prevWords, ["DROP", "TABLESPACE"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_tablespaces, currentWord) };
+	}
+	if (TailMatches(prevWords, ["DROP", "PUBLICATION"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_publications, currentWord) };
+	}
+	if (TailMatches(prevWords, ["DROP", "SUBSCRIPTION"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_subscriptions, currentWord) };
+	}
+	if (TailMatches(prevWords, ["DROP"])) return { candidates: filterAndCase(DROP_OBJECTS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["CREATE", "INDEX"])) return { candidates: filterAndCase(CREATE_INDEX_OPTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, [
+		"CREATE",
+		"UNIQUE",
+		"INDEX"
+	])) return { candidates: filterAndCase(CREATE_INDEX_OPTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, [
+		"CREATE",
+		"INDEX",
+		null
+	]) || TailMatches(prevWords, [
+		"CREATE",
+		"UNIQUE",
+		"INDEX",
+		null
+	])) return { candidates: filterAndCase(["ON"], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, [
+		"CREATE",
+		"INDEX",
+		null,
+		"ON"
+	]) || TailMatches(prevWords, [
+		"CREATE",
+		"INDEX",
+		"ON"
+	]) || TailMatches(prevWords, [
+		"CREATE",
+		"UNIQUE",
+		"INDEX",
+		null,
+		"ON"
+	]) || TailMatches(prevWords, [
+		"CREATE",
+		"UNIQUE",
+		"INDEX",
+		"ON"
+	])) return completeTables();
+	if ((HeadMatches(prevWords, ["CREATE", "INDEX"]) || HeadMatches(prevWords, [
+		"CREATE",
+		"UNIQUE",
+		"INDEX"
+	])) && TailMatches(prevWords, ["ON", null])) return { candidates: filterAndCase(["USING", "("], currentWord, ctx.settings) };
+	if ((HeadMatches(prevWords, ["CREATE", "INDEX"]) || HeadMatches(prevWords, [
+		"CREATE",
+		"UNIQUE",
+		"INDEX"
+	])) && TailMatches(prevWords, ["USING"])) {
+		if (!conn) return { candidates: filterAndCase([
+			"btree",
+			"hash",
+			"gist",
+			"gin",
+			"spgist",
+			"brin"
+		], currentWord, ctx.settings) };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_index_access_methods, currentWord) };
+	}
+	if (TailMatches(prevWords, ["CREATE"])) return { candidates: filterAndCase(CREATE_OBJECTS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["CREATE", "TABLE"])) return completeTables();
+	if (HeadMatches(prevWords, ["CREATE", "TABLE"]) && TailMatches(prevWords, ["(|,", null])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_datatypes, currentWord) };
+	}
+	if (TailMatches(prevWords, [
+		"CREATE",
+		"OR",
+		"REPLACE"
+	])) return { candidates: filterAndCase([
+		"FUNCTION",
+		"PROCEDURE",
+		"VIEW",
+		"TRIGGER",
+		"AGGREGATE",
+		"TRANSFORM"
+	], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["TRUNCATE"])) return { candidates: [...filterAndCase(["TABLE", "ONLY"], currentWord, ctx.settings), ...await tableCandidates(conn, currentWord)] };
+	if (TailMatches(prevWords, ["TRUNCATE", "TABLE"])) return completeTables();
+	if (TailMatches(prevWords, ["TRUNCATE", "ONLY"])) return completeTables();
+	if (HeadMatches(prevWords, ["COPY|\\copy"]) && HeadMatches(prevWords, [
+		null,
+		null,
+		"FROM"
+	]) && (TailMatches(prevWords, ["("]) || TailMatches(prevWords, [","]))) return { candidates: filterAndCase(COPY_FROM_OPTIONS, currentWord, ctx.settings) };
+	if (HeadMatches(prevWords, ["COPY|\\copy"]) && HeadMatches(prevWords, [
+		null,
+		null,
+		"TO"
+	]) && (TailMatches(prevWords, ["("]) || TailMatches(prevWords, [","]))) return { candidates: filterAndCase(COPY_TO_OPTIONS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["COPY"])) return completeTables();
+	if (TailMatches(prevWords, ["COPY", null])) return { candidates: filterAndCase(["FROM", "TO"], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ANALYZE"]) || TailMatches(prevWords, ["ANALYZE", "VERBOSE"])) return completeTables();
+	if (TailMatches(prevWords, ["VACUUM"]) || TailMatches(prevWords, ["VACUUM", "VERBOSE"])) return completeTables();
+	if (TailMatches(prevWords, ["VACUUM", "FULL"])) return completeTables();
+	if (TailMatches(prevWords, ["VACUUM", "ANALYZE"])) return completeTables();
+	if (TailMatches(prevWords, ["REINDEX"])) return { candidates: filterAndCase([
+		"TABLE",
+		"INDEX",
+		"SCHEMA",
+		"DATABASE",
+		"SYSTEM",
+		"CONCURRENTLY"
+	], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["REINDEX", "TABLE"])) return completeTables();
+	if (TailMatches(prevWords, ["REINDEX", "INDEX"])) return completeTables(Query_for_list_of_indexes);
+	if (TailMatches(prevWords, ["REINDEX", "SCHEMA"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord) };
+	}
+	if (TailMatches(prevWords, ["REINDEX", "DATABASE"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_databases, currentWord) };
+	}
+	if (TailMatches(prevWords, ["GRANT"]) || TailMatches(prevWords, ["REVOKE"])) return { candidates: filterAndCase(PRIVILEGE_KEYWORDS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ON"])) return completeTables();
+	if (TailMatches(prevWords, ["TO"])) {
+		if (HeadMatches(prevWords, ["GRANT"]) && conn) return { candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord) };
+	}
+	if (TailMatches(prevWords, ["FROM"]) && HeadMatches(prevWords, ["REVOKE"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord) };
+	}
+	if (TailMatches(prevWords, ["LOCK"])) return { candidates: [...filterAndCase(["TABLE"], currentWord, ctx.settings), ...await tableCandidates(conn, currentWord)] };
+	if (TailMatches(prevWords, ["LOCK", "TABLE"])) return completeTables();
+	if (TailMatches(prevWords, ["SET", "ROLE"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_roles, currentWord) };
+	}
+	if (TailMatches(prevWords, ["SET", "SCHEMA"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_schemas, currentWord) };
+	}
+	if (TailMatches(prevWords, ["SET", "SESSION"])) return { candidates: filterAndCase(["AUTHORIZATION", "CHARACTERISTICS AS TRANSACTION"], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["SET", "TRANSACTION"])) return { candidates: filterAndCase([
+		"ISOLATION LEVEL",
+		"READ ONLY",
+		"READ WRITE",
+		"DEFERRABLE"
+	], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, [
+		"SET",
+		"DateStyle",
+		"TO|="
+	]) || TailMatches(prevWords, [
+		"SET",
+		"DATESTYLE",
+		"TO|="
+	]) || TailMatches(prevWords, [
+		"SET",
+		"datestyle",
+		"TO|="
+	])) return { candidates: filterAndCase(DATESTYLE_VALUES, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, [
+		"SET",
+		"timezone",
+		"TO|="
+	]) || TailMatches(prevWords, [
+		"SET",
+		"TIMEZONE",
+		"TO|="
+	]) || TailMatches(prevWords, [
+		"SET",
+		"TimeZone",
+		"TO|="
+	])) {
+		if (!conn) return { candidates: [] };
+		const query = currentWord.startsWith("'") ? Query_for_list_of_timezone_names_quoted_in : Query_for_list_of_timezone_names_quoted_out;
+		return { candidates: await runCatalogQuery(conn, query, currentWord) };
+	}
+	if (TailMatches(prevWords, [
+		"SET",
+		null,
+		"TO|="
+	])) {
+		if (!conn) return { candidates: [] };
+		const gucName = prevWords[prevWords.length - 2];
+		return { candidates: await runCatalogQuery(conn, Query_for_values_of_enum_GUC, currentWord, [gucName]) };
+	}
+	if (TailMatches(prevWords, ["SET", null])) return { candidates: filterAndCase(["TO"], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["SET"])) {
+		const staticKw = filterAndCase([
+			"CONSTRAINTS",
+			"LOCAL",
+			"ROLE",
+			"SCHEMA",
+			"SESSION",
+			"TIME ZONE",
+			"TRANSACTION"
+		], currentWord, ctx.settings);
+		if (!conn) return { candidates: staticKw };
+		const guc = await runCatalogQuery(conn, Query_for_list_of_set_vars, currentWord);
+		return { candidates: [...staticKw, ...guc] };
+	}
+	if (TailMatches(prevWords, ["SHOW"])) {
+		const staticKw = filterAndCase(["ALL"], currentWord, ctx.settings);
+		if (!conn) return { candidates: [...staticKw, ...filterAndCase([
+			"search_path",
+			"role",
+			"session_authorization",
+			"transaction_isolation",
+			"client_encoding",
+			"server_encoding",
+			"server_version",
+			"timezone"
+		], currentWord, ctx.settings)] };
+		const guc = await runCatalogQuery(conn, Query_for_list_of_set_vars, currentWord);
+		return { candidates: [...staticKw, ...guc] };
+	}
+	if (TailMatches(prevWords, ["RESET"])) {
+		const staticKw = filterAndCase([
+			"ALL",
+			"SESSION AUTHORIZATION",
+			"ROLE"
+		], currentWord, ctx.settings);
+		if (!conn) return { candidates: staticKw };
+		const guc = await runCatalogQuery(conn, Query_for_list_of_set_vars, currentWord);
+		return { candidates: [...staticKw, ...guc] };
+	}
+	if (TailMatches(prevWords, ["BEGIN"]) || TailMatches(prevWords, ["START"])) return { candidates: filterAndCase(TRANSACTION_KEYWORDS, currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["ROLLBACK"])) return { candidates: filterAndCase([
+		"TO SAVEPOINT",
+		"TRANSACTION",
+		"AND CHAIN",
+		"AND NO CHAIN"
+	], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["EXPLAIN"])) return { candidates: filterAndCase([
+		"ANALYZE",
+		"VERBOSE",
+		"SELECT",
+		"INSERT INTO",
+		"UPDATE",
+		"DELETE FROM",
+		"("
+	], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["DECLARE"])) return { candidates: [] };
+	if (TailMatches(prevWords, ["CALL"])) {
+		if (!conn) return { candidates: [] };
+		return { candidates: await runCatalogQuery(conn, Query_for_list_of_functions, currentWord) };
+	}
+	if (TailMatches(prevWords, ["SELECT"])) return { candidates: filterAndCase([
+		"DISTINCT",
+		"ALL",
+		"*",
+		"CURRENT_DATE",
+		"CURRENT_TIME",
+		"CURRENT_TIMESTAMP",
+		"CURRENT_USER",
+		"NULL",
+		"TRUE",
+		"FALSE"
+	], currentWord, ctx.settings) };
+	if (TailMatches(prevWords, ["SELECT", "*"])) return { candidates: filterAndCase(["FROM"], currentWord, ctx.settings) };
+	return { candidates: [] };
 };
-// ---------------------------------------------------------------------------
-// Helpers.
-// ---------------------------------------------------------------------------
 /** Candidates for table-name completion, no schema-qualifier handling. */
 const tableCandidates = async (conn, word) => {
-    if (!conn)
-        return [];
-    return runCatalogQuery(conn, Query_for_list_of_tables, word);
+	if (!conn) return [];
+	return runCatalogQuery(conn, Query_for_list_of_tables, word);
 };
 /**
- * Schema-aware relation completion. If the user typed `schema.x`, fetch
- * relations in `schema` matching `x`. Otherwise fetch unqualified relations
- * AND a list of schemas (so the user can dot through to relations in any
- * schema, mirroring upstream's `complete_from_schema_query`).
- *
- * Schema names are returned with a trailing `.` so the completion engine
- * recognizes them as "in progress" and refrains from appending a space.
- * When a unique candidate is a schema (e.g. `pub<tab>` → `public.`) the
- * user can immediately Tab again to list relations within that schema.
- *
- * Quoted identifier handling: if the user's input starts with `"`, we
- * search the catalog case-sensitively (stripping the opening quote) and
- * return candidates pre-quoted with `"..."` so the line ends up in a
- * valid quoted form — matching upstream readline's behaviour for
- * `select * from "my<tab>` → `"mytab123 "mytab246`.
- */
+* Schema-aware relation completion. If the user typed `schema.x`, fetch
+* relations in `schema` matching `x`. Otherwise fetch unqualified relations
+* AND a list of schemas (so the user can dot through to relations in any
+* schema, mirroring upstream's `complete_from_schema_query`).
+*
+* Schema names are returned with a trailing `.` so the completion engine
+* recognizes them as "in progress" and refrains from appending a space.
+* When a unique candidate is a schema (e.g. `pub<tab>` → `public.`) the
+* user can immediately Tab again to list relations within that schema.
+*
+* Quoted identifier handling: if the user's input starts with `"`, we
+* search the catalog case-sensitively (stripping the opening quote) and
+* return candidates pre-quoted with `"..."` so the line ends up in a
+* valid quoted form — matching upstream readline's behaviour for
+* `select * from "my<tab>` → `"mytab123 "mytab246`.
+*/
 const completeSchemaOrRelations = async (conn, word, query) => {
-    if (word.startsWith('"')) {
-        return completeQuotedRelations(conn, word, query);
-    }
-    const split = splitSchemaPrefix(word);
-    if (split) {
-        const rows = await runCatalogQuery(conn, Query_for_list_of_relations_in_schema, split.prefix, [split.schema]);
-        // Re-prefix with the catalog's canonical schema name. Upstream folds
-        // unquoted schema identifiers to lowercase in the output (mirroring
-        // the way Postgres downcases unquoted names), so `PUBLIC.t<tab>`
-        // completes to `public.tab1` instead of preserving `PUBLIC` in the
-        // returned candidate.
-        const canonicalSchema = split.schemaWasQuoted
-            ? split.schema
-            : split.schema.toLowerCase();
-        return rows.map((r) => canonicalSchema + "." + r);
-    }
-    // Unqualified: combine relations + schemas (schemas suffixed with `.`).
-    const [rels, schemas] = await Promise.all([
-        runCatalogQuery(conn, query, word),
-        runCatalogQuery(conn, Query_for_list_of_schemas, word),
-    ]);
-    return [...rels, ...schemas.map((s) => s + ".")];
+	if (word.startsWith("\"")) return completeQuotedRelations(conn, word, query);
+	const split = splitSchemaPrefix(word);
+	if (split) {
+		const rows = await runCatalogQuery(conn, Query_for_list_of_relations_in_schema, split.prefix, [split.schema]);
+		const canonicalSchema = split.schemaWasQuoted ? split.schema : split.schema.toLowerCase();
+		return rows.map((r) => canonicalSchema + "." + r);
+	}
+	const [rels, schemas] = await Promise.all([runCatalogQuery(conn, query, word), runCatalogQuery(conn, Query_for_list_of_schemas, word)]);
+	return [...rels, ...schemas.map((s) => s + ".")];
 };
 /**
- * Search the catalog for relations matching a user-supplied prefix that
- * begins with `"`. We strip the opening quote, search the RAW relname
- * case-sensitively (so `"mi` → `mixedName` rather than `mytab123`), and
- * emit results wrapped in `"..."` with a closing quote so the editor's
- * unique-completion handler appends the trailing space outside the
- * quoted region (e.g. `"mixedName" `).
- */
+* Search the catalog for relations matching a user-supplied prefix that
+* begins with `"`. We strip the opening quote, search the RAW relname
+* case-sensitively (so `"mi` → `mixedName` rather than `mytab123`), and
+* emit results wrapped in `"..."` with a closing quote so the editor's
+* unique-completion handler appends the trailing space outside the
+* quoted region (e.g. `"mixedName" `).
+*/
 const completeQuotedRelations = async (conn, word, query) => {
-    // Strip leading `"` (and any trailing `"` the user pre-typed).
-    const inside = word.slice(1).replace(/"$/, "");
-    // Use a case-sensitive raw-relname LIKE — the inside-the-quote portion
-    // is taken verbatim.
-    const sql = caseSensitiveRelnameVariant(query);
-    if (!sql)
-        return [];
-    const rows = await runCatalogQuery(conn, sql, inside);
-    return rows.map((name) => '"' + name + '"');
+	const inside = word.slice(1).replace(/"$/, "");
+	const sql = caseSensitiveRelnameVariant(query);
+	if (!sql) return [];
+	return (await runCatalogQuery(conn, sql, inside)).map((name) => "\"" + name + "\"");
 };
 /**
- * Build a case-sensitive variant of a relation-list query for quoted
- * input. The standard queries use `ILIKE` on `quote_ident(c.relname)`
- * (which obscures the original case for identifiers like `mixedName`);
- * we swap that for `LIKE` on the raw `c.relname` and return the raw
- * relname so we control the quoting.
- *
- * Returns null if the query isn't a recognised relation query
- * (defensive — keeps the quoted-completion code path bounded).
- */
+* Build a case-sensitive variant of a relation-list query for quoted
+* input. The standard queries use `ILIKE` on `quote_ident(c.relname)`
+* (which obscures the original case for identifiers like `mixedName`);
+* we swap that for `LIKE` on the raw `c.relname` and return the raw
+* relname so we control the quoting.
+*
+* Returns null if the query isn't a recognised relation query
+* (defensive — keeps the quoted-completion code path bounded).
+*/
 const caseSensitiveRelnameVariant = (sql) => {
-    // We rewrite the SELECT/WHERE clauses on the standard relation queries.
-    // The only shape we need to support is `c.relname ILIKE $1` against
-    // `pg_catalog.pg_class c`, with various `c.relkind IN (...)` filters.
-    if (!sql.includes("pg_catalog.pg_class c"))
-        return null;
-    if (!sql.includes("c.relname ILIKE $1"))
-        return null;
-    return sql
-        .replace("SELECT pg_catalog.quote_ident(c.relname)", "SELECT c.relname")
-        .replace("c.relname ILIKE $1", "c.relname LIKE $1");
+	if (!sql.includes("pg_catalog.pg_class c")) return null;
+	if (!sql.includes("c.relname ILIKE $1")) return null;
+	return sql.replace("SELECT pg_catalog.quote_ident(c.relname)", "SELECT c.relname").replace("c.relname ILIKE $1", "c.relname LIKE $1");
 };
 /** Case-insensitive prefix filter; preserves the candidate's original casing. */
 const filterCi = (candidates, prefix) => {
-    if (prefix.length === 0)
-        return candidates.slice();
-    const lp = prefix.toLowerCase();
-    return candidates.filter((c) => c.toLowerCase().startsWith(lp));
+	if (prefix.length === 0) return candidates.slice();
+	const lp = prefix.toLowerCase();
+	return candidates.filter((c) => c.toLowerCase().startsWith(lp));
 };
 /** Names of variables currently SET on the settings (for `\unset` etc). */
 const listVarNames = (settings) => {
-    const out = [];
-    for (const [name] of settings.vars.entries())
-        out.push(name);
-    return out.sort();
+	const out = [];
+	for (const [name] of settings.vars.entries()) out.push(name);
+	return out.sort();
 };
 /** Both currently-set variables AND special-variable names. */
 const listAllVarNames = (settings) => {
-    const set = new Set();
-    for (const [name] of settings.vars.entries())
-        set.add(name);
-    for (const n of SPECIAL_VARIABLES)
-        set.add(n);
-    return [...set].sort();
+	const set = /* @__PURE__ */ new Set();
+	for (const [name] of settings.vars.entries()) set.add(name);
+	for (const n of SPECIAL_VARIABLES) set.add(n);
+	return [...set].sort();
 };
-// Re-exported so the index entrypoint can implement its own splitting helper
-// using the same prefix logic.
-export const _internals = { splitSchemaPrefix };
+const _internals = { splitSchemaPrefix };
+//#endregion
+export { ALTER_DATABASE_ACTIONS, ALTER_EXTENSION_ACTIONS, ALTER_FUNCTION_ACTIONS, ALTER_INDEX_ACTIONS, ALTER_MATVIEW_ACTIONS, ALTER_OBJECTS, ALTER_POLICY_ACTIONS, ALTER_PUBLICATION_ACTIONS, ALTER_ROLE_ACTIONS, ALTER_SCHEMA_ACTIONS, ALTER_SEQUENCE_ACTIONS, ALTER_SUBSCRIPTION_ACTIONS, ALTER_TABLE_ACTIONS, ALTER_TABLE_ADD, ALTER_TABLE_ALTER_COLUMN, ALTER_TABLE_DISABLE, ALTER_TABLE_DROP, ALTER_TABLE_ENABLE, ALTER_TABLE_RENAME, ALTER_TABLE_REPLICA_IDENTITY, ALTER_TABLE_SET, ALTER_TYPE_ACTIONS, ALTER_VIEW_ACTIONS, BACKSLASH_COMMANDS, BUILTIN_DATATYPE_KEYWORDS, COPY_FROM_OPTIONS, COPY_TO_OPTIONS, CREATE_INDEX_OPTIONS, CREATE_OBJECTS, DATESTYLE_VALUES, DROP_OBJECTS, POST_FROM_KEYWORDS, PRIVILEGE_KEYWORDS, SQL_TOP_KEYWORDS, TRANSACTION_KEYWORDS, WHERE_CONTINUATIONS, WINDOW_FRAME_KEYWORDS, _internals, findCompletions };