neonctl 2.28.0 → 2.29.0

package/dist/psql/core/mainloop.js

@@ -29,19 +29,19 @@
  *  - Encoding / multibyte handling beyond UTF-8 (handled implicitly by JS).
  *  - `\watch` continuous-execution mode.
  */
-import * as readline from 'node:readline';
-import { initialScanState } from '../types/scanner.js';
-import { scanSql } from '../scanner/sql.js';
-import { scanSlashArgs } from '../scanner/slash.js';
-import { renderPromptByName } from './prompt.js';
-import { captureLastError, pickOut, refreshErrorVars, renderResultSet, sendQuery, writeQueryError, } from './common.js';
-import { formatDurationMs } from '../print/units.js';
-import { COND_COMMAND_NAMES, attachCondStack, cmdElif, cmdElse, cmdEndif, cmdIf, } from '../command/cmd_cond.js';
-import { consumeNext as consumeQueuedInput } from '../command/inputQueue.js';
-import { consumeBindState, getPipelineState } from '../command/cmd_pipeline.js';
-import { appendHistory, defaultHistoryPath, loadHistory, resolveHistSize, truncateHistory, } from '../io/history.js';
-import { LineEditor } from '../io/lineEditor/index.js';
-import { psqlCompleter } from '../complete/index.js';
+import * as readline from "node:readline";
+import { attachCondStack, COND_COMMAND_NAMES, cmdElif, cmdElse, cmdEndif, cmdIf, } from "../command/cmd_cond.js";
+import { consumeBindState, getPipelineState } from "../command/cmd_pipeline.js";
+import { consumeNext as consumeQueuedInput } from "../command/inputQueue.js";
+import { psqlCompleter } from "../complete/index.js";
+import { appendHistory, defaultHistoryPath, loadHistory, resolveHistSize, truncateHistory, } from "../io/history.js";
+import { LineEditor } from "../io/lineEditor/index.js";
+import { formatDurationMs } from "../print/units.js";
+import { scanSlashArgs } from "../scanner/slash.js";
+import { scanSql } from "../scanner/sql.js";
+import { initialScanState } from "../types/scanner.js";
+import { captureLastError, pickOut, refreshErrorVars, renderResultSet, sendQuery, writeQueryError, } from "./common.js";
+import { renderPromptByName } from "./prompt.js";
 // ---------------------------------------------------------------------------
 // Exit codes — mirror psql's `EXIT_*` constants.
 // ---------------------------------------------------------------------------
@@ -54,10 +54,10 @@ export const EXIT_USER = 3;
 // registry lookup, because they must run even inside an inactive branch.
 // ---------------------------------------------------------------------------
 const COND_COMMANDS = new Map([
-    ['if', cmdIf],
-    ['elif', cmdElif],
-    ['else', cmdElse],
-    ['endif', cmdEndif],
+    ["if", cmdIf],
+    ["elif", cmdElif],
+    ["else", cmdElse],
+    ["endif", cmdEndif],
 ]);
 const makeStreamLineReader = (input, out) => {
     const rl = readline.createInterface({
@@ -79,7 +79,7 @@ const makeStreamLineReader = (input, out) => {
     const lineQueue = [];
     let waiter = null;
     let ended = false;
-    rl.on('line', (line) => {
+    rl.on("line", (line) => {
         if (waiter) {
             const w = waiter;
             waiter = null;
@@ -89,7 +89,7 @@ const makeStreamLineReader = (input, out) => {
             lineQueue.push(line);
         }
     });
-    rl.on('close', () => {
+    rl.on("close", () => {
         ended = true;
         if (waiter) {
             const w = waiter;
@@ -127,10 +127,10 @@ const makeStreamLineReader = (input, out) => {
  */
 const parseBoolVar = (raw) => {
     const v = raw.toLowerCase().trim();
-    if (v === '' || v === 'on' || v === 'true' || v === 'yes' || v === '1') {
+    if (v === "" || v === "on" || v === "true" || v === "yes" || v === "1") {
         return true;
     }
-    if (v === 'off' || v === 'false' || v === 'no' || v === '0') {
+    if (v === "off" || v === "false" || v === "no" || v === "0") {
         return false;
     }
     return null;
@@ -138,14 +138,14 @@ const parseBoolVar = (raw) => {
 /** Translate a psql VI_MODE var value into the LineEditor mode. */
 const viModeOption = (raw) => {
     if (raw === undefined)
-        return 'emacs';
-    return parseBoolVar(raw) === true ? 'vi' : 'emacs';
+        return "emacs";
+    return parseBoolVar(raw) === true ? "vi" : "emacs";
 };
 const makeEditorLineReader = async (ctx, opts = {}) => {
     const env = process.env;
     const histPath = defaultHistoryPath(env);
     const histSize = resolveHistSize(env);
-    const histControl = ctx.settings.vars.get('HISTCONTROL') ??
+    const histControl = ctx.settings.vars.get("HISTCONTROL") ??
         ctx.settings.histControl;
     let history = [];
     try {
@@ -158,7 +158,7 @@ const makeEditorLineReader = async (ctx, opts = {}) => {
     // VI_MODE: upstream readline's `set editing-mode {emacs|vi}`. We read once
     // here for the initial mode, and below we install a VarStore hook so a
     // subsequent `\set VI_MODE on` switches the editor at the next prompt.
-    const initialMode = viModeOption(ctx.settings.vars.get('VI_MODE'));
+    const initialMode = viModeOption(ctx.settings.vars.get("VI_MODE"));
     const editor = new LineEditor({
         stdin: ctx.stdin,
         stdout: ctx.stdout,
@@ -174,9 +174,9 @@ const makeEditorLineReader = async (ctx, opts = {}) => {
     // and on success forward to `editor.setMode` (which defers the switch to
     // the next readLine boundary). Replay on registration is fine — the hook
     // is idempotent for a no-op `null`/unchanged value.
-    ctx.settings.vars.addHook('VI_MODE', (newValue) => {
+    ctx.settings.vars.addHook("VI_MODE", (newValue) => {
         if (newValue === null) {
-            editor.setMode('emacs');
+            editor.setMode("emacs");
             return true;
         }
         const parsed = parseBoolVar(newValue);
@@ -184,7 +184,7 @@ const makeEditorLineReader = async (ctx, opts = {}) => {
             ctx.stderr.write(`\\set: VI_MODE: invalid value "${newValue}"; valid values: on, off\n`);
             return false;
         }
-        editor.setMode(parsed ? 'vi' : 'emacs');
+        editor.setMode(parsed ? "vi" : "emacs");
         return true;
     });
     return {
@@ -195,7 +195,7 @@ const makeEditorLineReader = async (ctx, opts = {}) => {
             return r;
         },
         pushHistory: (line) => {
-            const trimmed = line.replace(/\n+$/, '');
+            const trimmed = line.replace(/\n+$/, "");
             if (trimmed.length === 0)
                 return;
             editor.pushHistory(trimmed);
@@ -231,8 +231,8 @@ const isQuitKeyword = (line) => {
     const trimmed = line.trim();
     if (trimmed.length === 0)
         return false;
-    const stripped = trimmed.replace(/;+\s*$/u, '').trimEnd();
-    return stripped === 'exit' || stripped === 'quit';
+    const stripped = trimmed.replace(/;+\s*$/u, "").trimEnd();
+    return stripped === "exit" || stripped === "quit";
 };
 /**
  * Recognize the bare `help` keyword the same way upstream does: at the start
@@ -243,27 +243,27 @@ const isHelpKeyword = (line) => {
     const trimmed = line.trim();
     if (trimmed.length === 0)
         return false;
-    const stripped = trimmed.replace(/;+\s*$/u, '').trimEnd();
-    return stripped === 'help';
+    const stripped = trimmed.replace(/;+\s*$/u, "").trimEnd();
+    return stripped === "help";
 };
-const HELP_TEXT = 'You are using psql-ts, the embedded TypeScript psql in neonctl.\n' +
-    'Type:  \\copyright for distribution terms\n' +
-    '       \\h for help with SQL commands\n' +
-    '       \\? for help with psql commands\n' +
-    '       \\g or terminate with semicolon to execute query\n' +
-    '       \\q to quit\n';
+const HELP_TEXT = "You are using psql-ts, the embedded TypeScript psql in neonctl.\n" +
+    "Type:  \\copyright for distribution terms\n" +
+    "       \\h for help with SQL commands\n" +
+    "       \\? for help with psql commands\n" +
+    "       \\g or terminate with semicolon to execute query\n" +
+    "       \\q to quit\n";
 const makeLineReader = async (ctx, opts = {}) => {
-    const debug = process.env.NEONCTL_PSQL_DEBUG === '1';
+    const debug = process.env.NEONCTL_PSQL_DEBUG === "1";
     if (ctx.settings.notty) {
         if (debug) {
-            ctx.stderr.write('[psql-debug] notty=true; using stream reader (no line editor / no Tab completion)\n');
+            ctx.stderr.write("[psql-debug] notty=true; using stream reader (no line editor / no Tab completion)\n");
         }
         return makeStreamLineReader(ctx.stdin, ctx.stdout);
     }
     try {
         const r = await makeEditorLineReader(ctx, opts);
         if (debug) {
-            ctx.stderr.write('[psql-debug] LineEditor engaged (raw mode, Tab completion active)\n');
+            ctx.stderr.write("[psql-debug] LineEditor engaged (raw mode, Tab completion active)\n");
         }
         return r;
     }
@@ -277,22 +277,22 @@ const makeLineReader = async (ctx, opts = {}) => {
 const transactionState = (ctx) => {
     const db = ctx.settings.db;
     if (!db)
-        return 'idle';
+        return "idle";
     const status = db.txStatus;
     switch (status) {
-        case 'I':
-        case 'idle':
-            return 'idle';
-        case 'T':
-        case 'in-block':
-            return 'in-block';
-        case 'E':
-        case 'failed':
-            return 'failed';
-        case 'unknown':
-            return 'unknown';
+        case "I":
+        case "idle":
+            return "idle";
+        case "T":
+        case "in-block":
+            return "in-block";
+        case "E":
+        case "failed":
+            return "failed";
+        case "unknown":
+            return "unknown";
         default:
-            return 'idle';
+            return "idle";
     }
 };
 // ---------------------------------------------------------------------------
@@ -321,7 +321,7 @@ const makeBackslashContext = (ctx, cmdName, rawArgs, queryBuf) => {
         cmdName,
         queryBuf,
         rawArgs,
-        nextArg(mode = 'normal') {
+        nextArg(mode = "normal") {
             const args = argsFor(mode);
             const idx = cursors.get(mode) ?? 0;
             if (idx >= args.length)
@@ -351,7 +351,7 @@ const buildPromptContext = (ctx, promptStatus, lineNumber) => ({
     promptStatus,
     lineNumber,
     inTransaction: transactionState(ctx),
-    pipelineState: 'off',
+    pipelineState: "off",
 });
 // ---------------------------------------------------------------------------
 // Conditional-command dispatch. Returns true if the command was a cond
@@ -370,7 +370,7 @@ const dispatchCondCommand = async (ctx, cmdName, rawArgs, queryBuf) => {
     // these: commands using cmd_io's `errResult` (and inline writers) set it
     // to `true`; cond commands (which only stash `lastErrorResult.message`)
     // leave it unset so the mainloop surfaces the message.
-    if (result.status === 'error' &&
+    if (result.status === "error" &&
         !result.errorWritten &&
         ctx.settings.lastErrorResult?.message) {
         writeError(ctx, ctx.settings.lastErrorResult.message);
@@ -389,7 +389,7 @@ const dispatchRegisteredCommand = async (ctx, cmdName, rawArgs, queryBuf) => {
         // layer doesn't add a second one. (Other dispatch paths set
         // `lastErrorResult.message`; this one does not, so the duplicate
         // guard below would skip anyway — flag it explicitly for symmetry.)
-        return { status: 'error', errorWritten: true };
+        return { status: "error", errorWritten: true };
     }
     const bctx = makeBackslashContext(ctx, cmdName, rawArgs, queryBuf);
     attachCondStack(bctx, ctx.cond);
@@ -400,7 +400,7 @@ const dispatchRegisteredCommand = async (ctx, cmdName, rawArgs, queryBuf) => {
     // would emit a stray `psql: ERROR:  <msg>` line between the LINE/`^`
     // block and the `\errverbose` re-render, breaking the strict ordering
     // check in the conformance regex.
-    if (result.status === 'error' &&
+    if (result.status === "error" &&
         !result.errorWritten &&
         ctx.settings.lastErrorResult?.message) {
         writeError(ctx, ctx.settings.lastErrorResult.message);
@@ -426,9 +426,9 @@ const refreshConnectionVars = (ctx) => {
     const db = ctx.settings.db;
     if (!db)
         return;
-    const enc = db.parameterStatus('client_encoding');
-    if (enc !== undefined && ctx.settings.vars.get('ENCODING') !== enc) {
-        ctx.settings.vars.set('ENCODING', enc);
+    const enc = db.parameterStatus("client_encoding");
+    if (enc !== undefined && ctx.settings.vars.get("ENCODING") !== enc) {
+        ctx.settings.vars.set("ENCODING", enc);
     }
 };
 const dispatchSendQuery = async (ctx, sql) => {
@@ -457,15 +457,15 @@ const dispatchSendQuery = async (ctx, sql) => {
         const trimmed = sql.trimStart();
         if (/^COPY\b/i.test(trimmed) &&
             /\b(FROM\s+STDIN|TO\s+STDOUT)\b/i.test(trimmed)) {
-            ctx.stderr.write('psql: error: COPY in a pipeline is not supported, aborting connection\n');
+            ctx.stderr.write("psql: error: COPY in a pipeline is not supported, aborting connection\n");
             // Hard-abort the underlying socket so isClosed() flips true and the
             // mainloop's post-dispatch `checkConnectionLost` ends the loop.
             try {
                 const db = ctx.settings.db;
-                if (typeof db.abortForCopyInPipeline === 'function') {
+                if (typeof db.abortForCopyInPipeline === "function") {
                     db.abortForCopyInPipeline();
                 }
-                else if (typeof db.close === 'function') {
+                else if (typeof db.close === "function") {
                     await db.close();
                 }
             }
@@ -478,23 +478,23 @@ const dispatchSendQuery = async (ctx, sql) => {
             // Pipeline-mode `;`-queries: empty parameter list, anonymous prepared
             // statement, anonymous portal. The result will surface later through
             // `\endpipeline` / `\getresults`.
-            await ps.session.parse('', sql, []);
-            await ps.session.bind('', bind?.values ?? []);
+            await ps.session.parse("", sql, []);
+            await ps.session.bind("", bind?.values ?? []);
             const exec = (async () => {
-                await ps.session.execute('', 0);
+                await ps.session.execute("", 0);
                 return undefined;
             })();
             ps.pending.push(exec);
             // The enqueue succeeded; the actual result will flush at
             // `\endpipeline` time. Mark the diagnostic vars as success-now so
             // intervening `\echo :ERROR` sees "false" between pipeline appends.
-            refreshErrorVars(ctx.settings, { kind: 'success', rowCount: null });
+            refreshErrorVars(ctx.settings, { kind: "success", rowCount: null });
             return true;
         }
         catch (err) {
             const message = captureLastError(ctx.settings, err, sql);
             writeQueryError(ctx, message);
-            refreshErrorVars(ctx.settings, { kind: 'error' });
+            refreshErrorVars(ctx.settings, { kind: "error" });
             return false;
         }
     }
@@ -523,10 +523,10 @@ const dispatchSendQuery = async (ctx, sql) => {
         finally {
             refreshConnectionVars(ctx);
             refreshErrorVars(ctx.settings, hadError
-                ? { kind: 'error' }
-                : { kind: 'success', rowCount: lastRowCount });
+                ? { kind: "error" }
+                : { kind: "success", rowCount: lastRowCount });
             if (ctx.settings.timing) {
-                ctx.stdout.write('\n' + formatDurationMs(Date.now() - started) + '\n');
+                ctx.stdout.write("\n" + formatDurationMs(Date.now() - started) + "\n");
             }
         }
     }
@@ -581,18 +581,18 @@ const installNotificationHandler = (ctx, reader) => {
  * returned string directly.
  */
 const formatNotice = (notice, verbosity, showContext) => {
-    const severity = notice.severity || 'NOTICE';
-    const message = notice.message || '';
+    const severity = notice.severity || "NOTICE";
+    const message = notice.message || "";
     const lines = [];
-    if (verbosity === 'verbose' || verbosity === 'sqlstate') {
-        const sqlstate = notice.code ?? 'XX000';
+    if (verbosity === "verbose" || verbosity === "sqlstate") {
+        const sqlstate = notice.code ?? "XX000";
         lines.push(`${severity}:  ${sqlstate}: ${message}`);
     }
     else {
         lines.push(`${severity}:  ${message}`);
     }
-    if (verbosity === 'terse' || verbosity === 'sqlstate') {
-        return lines.join('\n') + '\n';
+    if (verbosity === "terse" || verbosity === "sqlstate") {
+        return lines.join("\n") + "\n";
     }
     if (notice.detail)
         lines.push(`DETAIL:  ${notice.detail}`);
@@ -603,19 +603,19 @@ const formatNotice = (notice, verbosity, showContext) => {
     //   - `default` shows CONTEXT only when SHOW_CONTEXT is `always` for
     //     non-error severities (NOTICE / WARNING / INFO / LOG / DEBUG), or
     //     when SHOW_CONTEXT is `errors`/`always` for ERROR-level entries.
-    const isError = severity === 'ERROR' || severity === 'FATAL' || severity === 'PANIC';
-    const includeContext = verbosity === 'verbose' ||
-        showContext === 'always' ||
-        (showContext === 'errors' && isError);
+    const isError = severity === "ERROR" || severity === "FATAL" || severity === "PANIC";
+    const includeContext = verbosity === "verbose" ||
+        showContext === "always" ||
+        (showContext === "errors" && isError);
     if (includeContext && notice.where) {
         lines.push(`CONTEXT:  ${notice.where}`);
     }
-    if (verbosity === 'verbose' && (notice.routine || notice.file)) {
-        const location = (notice.routine ?? '') +
-            (notice.file ? `, ${notice.file}:${notice.line ?? ''}` : '');
+    if (verbosity === "verbose" && (notice.routine || notice.file)) {
+        const location = (notice.routine ?? "") +
+            (notice.file ? `, ${notice.file}:${notice.line ?? ""}` : "");
         lines.push(`LOCATION:  ${location}`);
     }
-    return lines.join('\n') + '\n';
+    return lines.join("\n") + "\n";
 };
 /**
  * Subscribe to NoticeResponse on the active connection, rendering each to
@@ -637,7 +637,7 @@ const installNoticeHandler = (ctx, reader) => {
         // the NOTICE lands AT the result boundary, not before. Emitting here too
         // would duplicate every notice — once when the wire layer parses it,
         // once when the drain walks `rs.notices`.
-        if (ctx.settings.sendMode === 'extended-pipeline')
+        if (ctx.settings.sendMode === "extended-pipeline")
             return;
         const text = formatNotice(notice, ctx.settings.verbosity, ctx.settings.showContext);
         // Notices go to stderr (libpq default). The LineEditor's prompt-redraw
@@ -662,8 +662,8 @@ const installSigint = (ctx, state) => {
         }
         state.resetBuf();
     };
-    process.on('SIGINT', handler);
-    return () => process.off('SIGINT', handler);
+    process.on("SIGINT", handler);
+    return () => process.off("SIGINT", handler);
 };
 // ---------------------------------------------------------------------------
 // The main entry point.
@@ -674,7 +674,7 @@ export const runMainLoop = async (ctx) => {
     // on every Tab. The mainloop reassigns this variable across statements
     // (resetBuf, after dispatch); the closure stays valid because it captures
     // the binding, not a snapshot.
-    let queryBuf = '';
+    let queryBuf = "";
     const reader = await makeLineReader(ctx, { getQueryBuf: () => queryBuf });
     let scanState = initialScanState();
     let stmtLineNumber = 1;
@@ -689,7 +689,7 @@ export const runMainLoop = async (ctx) => {
     // in lock-step with cond.push / cond.pop / cond.setSavedQueryBufLen.
     const condScanStateStack = [];
     const resetBuf = () => {
-        queryBuf = '';
+        queryBuf = "";
         scanState = initialScanState();
         stmtLineNumber = 1;
     };
@@ -699,7 +699,7 @@ export const runMainLoop = async (ctx) => {
     // we halt the loop instead so we don't spam ERROR lines for every one.
     const checkConnectionLost = () => {
         if (ctx.settings.db?.isClosed()) {
-            ctx.stderr.write('psql: error: connection to server was lost\n');
+            ctx.stderr.write("psql: error: connection to server was lost\n");
             successResult = EXIT_BADCONN;
             exitRequested = true;
             return true;
@@ -726,12 +726,12 @@ export const runMainLoop = async (ctx) => {
     // with stdout. For TTY input the LineEditor renders the prompt itself.
     const computePrompt = (status) => {
         if (ctx.settings.notty)
-            return '';
-        const name = queryBuf.trim().length === 0 || status === 'ready'
-            ? 'PROMPT1'
-            : status === 'copy'
-                ? 'PROMPT3'
-                : 'PROMPT2';
+            return "";
+        const name = queryBuf.trim().length === 0 || status === "ready"
+            ? "PROMPT1"
+            : status === "copy"
+                ? "PROMPT3"
+                : "PROMPT2";
         const promptCtx = buildPromptContext(ctx, status, stmtLineNumber);
         return renderPromptByName(name, promptCtx);
     };
@@ -749,8 +749,8 @@ export const runMainLoop = async (ctx) => {
         const spec = ctx.registry.lookup(cmdName);
         if (!spec)
             return undefined;
-        if (spec.argMode === 'whole-line')
-            return 'whole-line';
+        if (spec.argMode === "whole-line")
+            return "whole-line";
         // Backslash registry currently only distinguishes whole-line vs the
         // default `lex` mode. Filepipe is signalled per-call via
         // `nextArg('filepipe')` inside cmd implementations rather than the
@@ -758,15 +758,15 @@ export const runMainLoop = async (ctx) => {
         // upstream declares as `OT_FILEPIPE` (`\w` and `\o`). Without this,
         // `\w |/no/such/file \else` would split off `\else` as a separate
         // command instead of capturing it as the file's whole-line arg.
-        if (cmdName === 'w' || cmdName === 'o')
-            return 'filepipe';
+        if (cmdName === "w" || cmdName === "o")
+            return "filepipe";
         return undefined;
     };
     /**
      * Strip block / line comments cheaply before scanning so a COPY-shaped
      * comment doesn't trigger pre-buffering or sink wiring.
      */
-    const stripSqlComments = (sql) => sql.replace(/\/\*[\s\S]*?\*\//g, '').replace(/--[^\n]*/g, '');
+    const stripSqlComments = (sql) => sql.replace(/\/\*[\s\S]*?\*\//g, "").replace(/--[^\n]*/g, "");
     /**
      * Count the number of `COPY ... FROM STDIN` segments in `sql`. Upstream
      * `handleCopyIn` in copy.c is invoked for each one that hits the wire as
@@ -808,10 +808,10 @@ export const runMainLoop = async (ctx) => {
     const readCopyDataBlock = async () => {
         const lines = [];
         for (;;) {
-            const line = await reader.readLine('');
+            const line = await reader.readLine("");
             if (line === null)
                 break;
-            if (line.replace(/\s+$/, '') === '\\.')
+            if (line.replace(/\s+$/, "") === "\\.")
                 break;
             lines.push(line);
             // Upstream `handleCopyIn` in copy.c reads COPY data lines straight
@@ -824,8 +824,8 @@ export const runMainLoop = async (ctx) => {
         }
         // Each line plus a trailing newline — matches the byte stream COPY
         // expects on its input side.
-        const text = lines.length === 0 ? '' : lines.join('\n') + '\n';
-        return Buffer.from(text, 'utf8');
+        const text = lines.length === 0 ? "" : lines.join("\n") + "\n";
+        return Buffer.from(text, "utf8");
     };
     /**
      * Process the assembled queryBuf+line through scanSql, dispatching the
@@ -842,11 +842,11 @@ export const runMainLoop = async (ctx) => {
                 singleline: ctx.settings.singleline,
             });
             scanState = result.nextState;
-            if (result.kind === 'semicolon') {
+            if (result.kind === "semicolon") {
                 // Use the substituted `result.sql` so `:NAME` references already
                 // resolved at scan time make it into the executed SQL.
                 const sqlText = queryBuf + result.sql;
-                queryBuf = '';
+                queryBuf = "";
                 working = working.slice(result.consumed);
                 scanState = initialScanState();
                 stmtLineNumber = 1;
@@ -861,14 +861,16 @@ export const runMainLoop = async (ctx) => {
                 // layer before dispatch. Mirrors upstream `handleCopyIn` in
                 // copy.c — except we pump the bytes up-front instead of via a
                 // callback into the REPL when CopyInResponse arrives.
-                const copyCount = ctx.settings.db ? countCopyFromStdin(sqlText) : 0;
+                const copyCount = ctx.settings.db
+                    ? countCopyFromStdin(sqlText)
+                    : 0;
                 const wantsCopyOut = ctx.settings.db !== undefined && hasCopyToStdout(sqlText);
                 if (copyCount > 0 && ctx.settings.db) {
                     // The Connection type doesn't expose `queueCopyInData` (kept
                     // off the frozen interface), but the concrete PgConnection
                     // does. We duck-type the method to avoid coupling here.
                     const conn = ctx.settings.db;
-                    if (typeof conn.queueCopyInData === 'function') {
+                    if (typeof conn.queueCopyInData === "function") {
                         // Drop any leftover buffers from a previous (failed) batch so
                         // we don't accidentally re-use stale data.
                         conn.clearCopyInDataQueue?.();
@@ -917,7 +919,7 @@ export const runMainLoop = async (ctx) => {
                 }
                 continue;
             }
-            if (result.kind === 'backslash') {
+            if (result.kind === "backslash") {
                 // Fold buffered SQL accumulated before the backslash into queryBuf.
                 // `result.sql` carries the (possibly empty) text that preceded the
                 // backslash in this scan pass — empty when the backslash was at the
@@ -955,7 +957,7 @@ export const runMainLoop = async (ctx) => {
                     // small immutable objects.
                     const scanStateBefore = { ...scanState };
                     const r = await dispatchCondCommand(ctx, cmdName, result.rest, queryBuf);
-                    if (r.handled && r.result?.status === 'exit') {
+                    if (r.handled && r.result?.status === "exit") {
                         exitRequested = true;
                         return;
                     }
@@ -986,24 +988,26 @@ export const runMainLoop = async (ctx) => {
                     //                   inactive restoration (so the new branch
                     //                   starts from a clean checkpoint).
                     // `\endif`        → pop the top entry.
-                    if (cmdName === 'if') {
+                    if (cmdName === "if") {
                         condScanStateStack.push(scanStateBefore);
                     }
-                    else if (cmdName === 'elif' || cmdName === 'else') {
+                    else if (cmdName === "elif" || cmdName === "else") {
                         // Errors leave the top untouched (cond.setState not called on
                         // the no-matching/double-else paths). Only re-anchor when the
                         // command succeeded — `status: 'ok'` covers both the active
                         // and truncated paths.
-                        if (condScanStateStack.length > 0 && r.result?.status === 'ok') {
-                            condScanStateStack[condScanStateStack.length - 1] = {
-                                ...scanState,
-                            };
+                        if (condScanStateStack.length > 0 &&
+                            r.result?.status === "ok") {
+                            condScanStateStack[condScanStateStack.length - 1] =
+                                {
+                                    ...scanState,
+                                };
                         }
                     }
-                    else if (cmdName === 'endif') {
+                    else if (cmdName === "endif") {
                         // Pop only on success — `\endif` with no matching `\if`
                         // returns an error and doesn't actually pop the cond frame.
-                        if (r.result?.status === 'ok') {
+                        if (r.result?.status === "ok") {
                             condScanStateStack.pop();
                         }
                     }
@@ -1014,7 +1018,7 @@ export const runMainLoop = async (ctx) => {
                     // the terminal `lastWasError → EXIT_USER` escalation. Only
                     // ON_ERROR_STOP can escalate cond failures.
                     if (r.handled &&
-                        r.result?.status === 'error' &&
+                        r.result?.status === "error" &&
                         ctx.settings.onErrorStop) {
                         successResult = EXIT_USER;
                         exitRequested = true;
@@ -1050,12 +1054,12 @@ export const runMainLoop = async (ctx) => {
                     continue;
                 }
                 const bres = await dispatchRegisteredCommand(ctx, cmdName, result.rest, queryBuf);
-                if (bres?.status === 'exit') {
+                if (bres?.status === "exit") {
                     exitRequested = true;
                     return;
                 }
-                if (bres?.status === 'reset-buf') {
-                    queryBuf = bres.newBuf ?? '';
+                if (bres?.status === "reset-buf") {
+                    queryBuf = bres.newBuf ?? "";
                     scanState = initialScanState();
                     stmtLineNumber = 1;
                     // The SQL scanner intentionally stops the backslash boundary on
@@ -1083,10 +1087,11 @@ export const runMainLoop = async (ctx) => {
                     // through-newline behaviour for the buffer-reset case — without
                     // changing the scanner's semantics for the inline-slash + multi-
                     // line shape that depends on the `\n` surviving.
-                    if (working.startsWith('\r\n')) {
+                    if (working.startsWith("\r\n")) {
                         working = working.slice(2);
                     }
-                    else if (working.startsWith('\n') || working.startsWith('\r')) {
+                    else if (working.startsWith("\n") ||
+                        working.startsWith("\r")) {
                         working = working.slice(1);
                     }
                 }
@@ -1101,11 +1106,12 @@ export const runMainLoop = async (ctx) => {
                 // would assemble the SELECT's queryBuf as `\n` + `SELECT...` —
                 // shifting the server's `LINE N` count by one and contaminating
                 // the `STATEMENT:  ...` echo emitted on error.
-                if (bres?.status !== 'reset-buf' && slashOnlyLine) {
-                    if (working.startsWith('\r\n')) {
+                if (bres?.status !== "reset-buf" && slashOnlyLine) {
+                    if (working.startsWith("\r\n")) {
                         working = working.slice(2);
                     }
-                    else if (working.startsWith('\n') || working.startsWith('\r')) {
+                    else if (working.startsWith("\n") ||
+                        working.startsWith("\r")) {
                         working = working.slice(1);
                     }
                 }
@@ -1124,8 +1130,8 @@ export const runMainLoop = async (ctx) => {
                 // newline. Without this, `\bind_named NAME 1 2 \gset pref02_ \echo X`
                 // would still execute `\echo X` after the pipeline-mode `\gset`
                 // rejection — vanilla suppresses it.
-                if (bres?.status === 'error') {
-                    queryBuf = '';
+                if (bres?.status === "error") {
+                    queryBuf = "";
                     scanState = initialScanState();
                     stmtLineNumber = 1;
                     // Discard any trailing content on the SAME physical line — but NOT
@@ -1139,21 +1145,22 @@ export const runMainLoop = async (ctx) => {
                     // discard). Without this branch a stack of `\gdesc\n\gdesc\n…`
                     // lines collapses to a single dispatched `\gdesc` because the
                     // first discard ate the second line.
-                    if (working.startsWith('\r\n')) {
+                    if (working.startsWith("\r\n")) {
                         working = working.slice(2);
                     }
-                    else if (working.startsWith('\n') || working.startsWith('\r')) {
+                    else if (working.startsWith("\n") ||
+                        working.startsWith("\r")) {
                         working = working.slice(1);
                     }
                     else {
-                        const nlIdx = working.indexOf('\n');
-                        working = nlIdx === -1 ? '' : working.slice(nlIdx + 1);
+                        const nlIdx = working.indexOf("\n");
+                        working = nlIdx === -1 ? "" : working.slice(nlIdx + 1);
                     }
                 }
                 // Backslash commands like \connect can also tear down the connection.
                 if (checkConnectionLost())
                     return;
-                if (bres?.status === 'error' && ctx.settings.onErrorStop) {
+                if (bres?.status === "error" && ctx.settings.onErrorStop) {
                     successResult = EXIT_USER;
                     exitRequested = true;
                     return;
@@ -1168,7 +1175,7 @@ export const runMainLoop = async (ctx) => {
             // current buffer; the line-reader feeds whole lines so this is
             // effectively unreachable in interactive use.)
             queryBuf += result.sql;
-            working = '';
+            working = "";
             return;
         }
     };
@@ -1191,15 +1198,15 @@ export const runMainLoop = async (ctx) => {
             // residue (e.g. a trailing `\n` left over after a `;` boundary) counts
             // as empty so the next prompt is PROMPT1 not PROMPT2.
             const status = queryBuf.trim().length === 0
-                ? 'ready'
-                : scanState.promptStatus === 'ready'
-                    ? 'continue'
+                ? "ready"
+                : scanState.promptStatus === "ready"
+                    ? "continue"
                     : scanState.promptStatus;
             const prompt = computePrompt(status);
             // 1. Pending input from \i: process as a single chunk and loop again.
             const queued = consumeQueuedInput();
             if (queued !== null) {
-                await processChunk(queued.endsWith('\n') ? queued : queued + '\n');
+                await processChunk(queued.endsWith("\n") ? queued : queued + "\n");
                 continue;
             }
             // 2. Read the next line from stdin / line editor.
@@ -1210,7 +1217,7 @@ export const runMainLoop = async (ctx) => {
             catch (err) {
                 // SignalError (Ctrl-C on an interactive line) — drop the partial
                 // buffer and re-prompt, matching upstream psql.
-                if (err.name === 'SignalError') {
+                if (err.name === "SignalError") {
                     resetBuf();
                     continue;
                 }
@@ -1251,8 +1258,8 @@ export const runMainLoop = async (ctx) => {
             // the scanner is mid-quote and the line is part of the assembled
             // statement. ECHO=queries echoes only completed queries — handled
             // separately by the exec path.
-            if (ctx.settings.echo === 'all') {
-                ctx.stdout.write(line + '\n');
+            if (ctx.settings.echo === "all") {
+                ctx.stdout.write(line + "\n");
             }
             // 2a. `exit`/`quit` keyword handling.
             //
@@ -1273,7 +1280,7 @@ export const runMainLoop = async (ctx) => {
                     exitRequested = true;
                     break;
                 }
-                ctx.stdout.write('Use \\q to quit.\n');
+                ctx.stdout.write("Use \\q to quit.\n");
                 continue;
             }
             // 2b. `help` keyword handling, same shape.
@@ -1286,14 +1293,14 @@ export const runMainLoop = async (ctx) => {
                     ctx.stdout.write(HELP_TEXT);
                 }
                 else {
-                    ctx.stdout.write('Use \\? for help.\n');
+                    ctx.stdout.write("Use \\? for help.\n");
                 }
                 continue;
             }
             // 3. Push to history once we have a complete submitted line (only
             //    when there's something non-blank to record).
             reader.pushHistory(line);
-            await processChunk(line + '\n');
+            await processChunk(line + "\n");
         }
         // EOF: if there's a residual non-empty buffer in non-interactive mode,
         // dispatch it (mirroring upstream's tail-of-MainLoop block). For
@@ -1310,18 +1317,18 @@ export const runMainLoop = async (ctx) => {
                 const ok = await dispatchSendQuery(ctx, queryBuf);
                 sigintState.inQuery = false;
                 if (ctx.settings.db?.isClosed()) {
-                    ctx.stderr.write('psql: error: connection to server was lost\n');
+                    ctx.stderr.write("psql: error: connection to server was lost\n");
                     successResult = EXIT_BADCONN;
                 }
                 else if (!ok && ctx.settings.onErrorStop) {
                     successResult = EXIT_USER;
                 }
             }
-            queryBuf = '';
+            queryBuf = "";
         }
         // Warn about unbalanced \if blocks (psql's tail-of-MainLoop check).
         if (!exitRequested && ctx.cond.depth() > 0) {
-            writeError(ctx, 'reached EOF without finding closing \\endif(s)');
+            writeError(ctx, "reached EOF without finding closing \\endif(s)");
             if (ctx.settings.onErrorStop && ctx.settings.notty) {
                 successResult = EXIT_USER;
             }