neonctl 2.28.0 → 2.29.1

package/dist/psql/command/cmd_io.js

@@ -76,23 +76,23 @@
  * that and also stash the message on `settings.lastErrorResult` so the
  * mainloop's `writeError()` wrapper can pick it up.
  */
-import { spawn } from 'node:child_process';
-import { promises as fsPromises, closeSync, createWriteStream, fsyncSync, openSync, } from 'node:fs';
-import * as path from 'node:path';
-import { platform } from 'node:os';
-import { alignedPrinter } from '../print/aligned.js';
-import { asciidocPrinter } from '../print/asciidoc.js';
-import { csvPrinter } from '../print/csv.js';
-import { htmlPrinter } from '../print/html.js';
-import { jsonPrinter } from '../print/json.js';
-import { latexLongtablePrinter, latexPrinter } from '../print/latex.js';
-import { troffMsPrinter } from '../print/troff.js';
-import { unalignedPrinter } from '../print/unaligned.js';
-import { writeErr, writeOut } from './shared.js';
-import { formatErrorReport, psqlErrorPrefix } from './cmd_meta.js';
-import { applyPset } from './cmd_format.js';
-import { consumeBindState, lookupPrepared, stagedNamedBindPresent, } from './cmd_pipeline.js';
-import { captureLastError, refreshErrorVars, stripLeadingCommentsAndWS, } from '../core/common.js';
+import { spawn } from "node:child_process";
+import { closeSync, createWriteStream, promises as fsPromises, fsyncSync, openSync, } from "node:fs";
+import { platform } from "node:os";
+import * as path from "node:path";
+import { captureLastError, refreshErrorVars, stripLeadingCommentsAndWS, } from "../core/common.js";
+import { alignedPrinter } from "../print/aligned.js";
+import { asciidocPrinter } from "../print/asciidoc.js";
+import { csvPrinter } from "../print/csv.js";
+import { htmlPrinter } from "../print/html.js";
+import { jsonPrinter } from "../print/json.js";
+import { latexLongtablePrinter, latexPrinter } from "../print/latex.js";
+import { troffMsPrinter } from "../print/troff.js";
+import { unalignedPrinter } from "../print/unaligned.js";
+import { applyPset } from "./cmd_format.js";
+import { formatErrorReport, psqlErrorPrefix } from "./cmd_meta.js";
+import { consumeBindState, lookupPrepared, stagedNamedBindPresent, } from "./cmd_pipeline.js";
+import { writeErr, writeOut } from "./shared.js";
 // ---------------------------------------------------------------------------
 // Query-output (queryFout) stash.
 //
@@ -101,7 +101,7 @@ import { captureLastError, refreshErrorVars, stripLeadingCommentsAndWS, } from '
 // at WP-00, so we stash the stream on the settings object via a well-known
 // symbol — the same approach used for the CondStack in cmd_cond.ts.
 // ---------------------------------------------------------------------------
-const QUERY_FOUT_KEY = Symbol.for('neonctl.psql.queryFout');
+const QUERY_FOUT_KEY = Symbol.for("neonctl.psql.queryFout");
 /**
  * Return the currently active queryFout stream (or `null` if none).
  * The mainloop is encouraged to call this in lieu of writing directly to
@@ -152,7 +152,7 @@ const errResult = (ctx, message) => {
     // it would also write a `psql: ERROR:  <msg>` fallback, producing a stray
     // duplicate that breaks the `\errverbose` ordering check on tests like
     // `SELECT error\gdesc\n\errverbose`.
-    return { status: 'error', errorWritten: true };
+    return { status: "error", errorWritten: true };
 };
 /**
  * Reject buffer-consuming commands when an extended pipeline is open. Upstream
@@ -182,7 +182,7 @@ const errResult = (ctx, message) => {
  * own). Mirror that with a settings-stashed accumulator keyed off the
  * current pipeline session; reset when the pipeline ends.
  */
-const PIPELINE_GATE_ERRORS_KEY = Symbol.for('neonctl.psql.pipelineGateErrors');
+const PIPELINE_GATE_ERRORS_KEY = Symbol.for("neonctl.psql.pipelineGateErrors");
 const getGateErrors = (settings) => {
     const s = settings;
     let cur = s[PIPELINE_GATE_ERRORS_KEY];
@@ -203,10 +203,10 @@ export const clearPipelineGateErrors = (settings) => {
     s[PIPELINE_GATE_ERRORS_KEY] = undefined;
 };
 const pipelineGate = (ctx) => {
-    if (ctx.settings.sendMode !== 'extended-pipeline')
+    if (ctx.settings.sendMode !== "extended-pipeline")
         return null;
-    const message = ctx.cmdName === 'gdesc'
-        ? 'synchronous command execution functions are not allowed in pipeline mode'
+    const message = ctx.cmdName === "gdesc"
+        ? "synchronous command execution functions are not allowed in pipeline mode"
         : `\\${ctx.cmdName} not allowed in pipeline mode`;
     ctx.settings.lastErrorResult = { message };
     const prefix = psqlErrorPrefix(ctx.settings);
@@ -218,7 +218,7 @@ const pipelineGate = (ctx) => {
     // the session-scoped error log; other gated commands (`\g`, `\gx`,
     // `\gset`, `\gexec`, `\watch`) emit a single line per invocation
     // and do NOT participate in the accumulator.
-    if (ctx.cmdName === 'gdesc') {
+    if (ctx.cmdName === "gdesc") {
         const log = getGateErrors(ctx.settings);
         log.push(message);
         for (const m of log) {
@@ -228,7 +228,7 @@ const pipelineGate = (ctx) => {
     else {
         writeErr(`${prefix}${message}\n`);
     }
-    return { status: 'error', errorWritten: true };
+    return { status: "error", errorWritten: true };
 };
 /**
  * Set of psql variables upstream marks as "specially treated" — i.e. names
@@ -242,28 +242,28 @@ const pipelineGate = (ctx) => {
  * for us.
  */
 const UPSTREAM_SPECIAL_VAR_NAMES = new Set([
-    'AUTOCOMMIT',
-    'COMP_KEYWORD_CASE',
-    'ECHO',
-    'ECHO_HIDDEN',
-    'FETCH_COUNT',
-    'HIDE_TABLEAM',
-    'HIDE_TOAST_COMPRESSION',
-    'HISTCONTROL',
-    'HISTFILE',
-    'HISTSIZE',
-    'IGNOREEOF',
-    'ON_ERROR_ROLLBACK',
-    'ON_ERROR_STOP',
-    'PROMPT1',
-    'PROMPT2',
-    'PROMPT3',
-    'QUIET',
-    'SHOW_ALL_RESULTS',
-    'SHOW_CONTEXT',
-    'SINGLELINE',
-    'SINGLESTEP',
-    'VERBOSITY',
+    "AUTOCOMMIT",
+    "COMP_KEYWORD_CASE",
+    "ECHO",
+    "ECHO_HIDDEN",
+    "FETCH_COUNT",
+    "HIDE_TABLEAM",
+    "HIDE_TOAST_COMPRESSION",
+    "HISTCONTROL",
+    "HISTFILE",
+    "HISTSIZE",
+    "IGNOREEOF",
+    "ON_ERROR_ROLLBACK",
+    "ON_ERROR_STOP",
+    "PROMPT1",
+    "PROMPT2",
+    "PROMPT3",
+    "QUIET",
+    "SHOW_ALL_RESULTS",
+    "SHOW_CONTEXT",
+    "SINGLELINE",
+    "SINGLESTEP",
+    "VERBOSITY",
 ]);
 /**
  * True when `name` is a psql variable that `\gset` must skip with an
@@ -273,7 +273,8 @@ const UPSTREAM_SPECIAL_VAR_NAMES = new Set([
  * IGNOREEOF that aren't hooked in our settings.ts still match upstream's
  * `\gset` behaviour exactly).
  */
-const isSpeciallyTreatedVar = (settings, name) => settings.vars.hasSubstituteHook(name) || UPSTREAM_SPECIAL_VAR_NAMES.has(name);
+const isSpeciallyTreatedVar = (settings, name) => settings.vars.hasSubstituteHook(name) ||
+    UPSTREAM_SPECIAL_VAR_NAMES.has(name);
 // `stripLeadingCommentsAndWS` lives in core/common.ts so the wire path
 // (sendQuery / executeAndPrint) and the slash-command paths share one
 // implementation. Re-imported from there at the top of the file.
@@ -287,7 +288,7 @@ const isSpeciallyTreatedVar = (settings, name) => settings.vars.hasSubstituteHoo
  * intentionally conservative, and the worst-case outcome is "route bytes
  * that never arrive to the file" — harmless).
  */
-const stripSqlCommentsForCopyScan = (sql) => sql.replace(/\/\*[\s\S]*?\*\//gu, '').replace(/--[^\n]*/gu, '');
+const stripSqlCommentsForCopyScan = (sql) => sql.replace(/\/\*[\s\S]*?\*\//gu, "").replace(/--[^\n]*/gu, "");
 /**
  * True when `sql` contains at least one `COPY ... TO STDOUT` segment.
  * Used by `runGCore` to install a CopyData sink while `\g` / `\gx` /
@@ -323,7 +324,7 @@ const formatServerError = (ctx, err, sql) => {
         const lines = formatErrorReport(e, ctx.settings.verbosity, ctx.settings.showContext);
         const prefix = psqlErrorPrefix(ctx.settings);
         const prefixed = [prefix + lines[0], ...lines.slice(1)];
-        writeErr(prefixed.join('\n') + '\n');
+        writeErr(prefixed.join("\n") + "\n");
     }
     else {
         // Defensive fallback — captureLastError always sets lastErrorResult,
@@ -335,8 +336,8 @@ const formatServerError = (ctx, err, sql) => {
     // following `\echo :LAST_ERROR_MESSAGE` and `\errverbose` see the new
     // outcome. Matches upstream's `SetErrorVariables` call after every
     // failed dispatch.
-    refreshErrorVars(ctx.settings, { kind: 'error' });
-    return { status: 'error', errorWritten: true };
+    refreshErrorVars(ctx.settings, { kind: "error" });
+    return { status: "error", errorWritten: true };
 };
 /**
  * Open a writable destination for `\o` / `\w` / `\g FILE` / `\g |cmd`.
@@ -348,15 +349,15 @@ const formatServerError = (ctx, err, sql) => {
  * file path; the file is truncated.
  */
 const openWriter = (target) => {
-    if (target.startsWith('|')) {
+    if (target.startsWith("|")) {
         const cmd = target.slice(1);
-        const child = spawn('sh', ['-c', cmd], {
-            stdio: ['pipe', 'inherit', 'inherit'],
+        const child = spawn("sh", ["-c", cmd], {
+            stdio: ["pipe", "inherit", "inherit"],
         });
         // Swallow EPIPE on the stdin pipe — the child may exit before we
         // finish writing, and Node would otherwise raise an unhandled error.
-        child.stdin.on('error', (err) => {
-            if (err.code !== 'EPIPE') {
+        child.stdin.on("error", (err) => {
+            if (err.code !== "EPIPE") {
                 // Re-raise non-EPIPE errors as a crash so they show up; tests
                 // run with the default unhandledRejection handler and will see
                 // these via the failing assertion.
@@ -374,10 +375,10 @@ const openWriter = (target) => {
                     settled = true;
                     resolve({ exitCode: code, signal });
                 };
-                child.once('close', (code, signal) => {
+                child.once("close", (code, signal) => {
                     finish(code, signal);
                 });
-                child.once('error', () => {
+                child.once("error", () => {
                     // spawn failure or stdio glitch — treat as a non-zero exit so
                     // \w sees a failure. \g intentionally ignores this, mirroring
                     // upstream `CloseGOutput` which only sets SHELL_ERROR /
@@ -406,9 +407,9 @@ const openWriter = (target) => {
     // a follow-on server-side `COPY FROM` (Docker bind-mount on macOS) sees
     // the fully flushed file even when the next command immediately follows
     // the `\g`.
-    const fd = openSync(target, 'w');
+    const fd = openSync(target, "w");
     const stream = createWriteStream(target, {
-        encoding: 'utf8',
+        encoding: "utf8",
         fd,
         autoClose: false,
     });
@@ -418,7 +419,7 @@ const openWriter = (target) => {
     // re-raises it as an uncaught exception and kills the whole neonctl process.
     // Capture it; close() surfaces it to the caller.
     let writeError = null;
-    stream.on('error', (err) => {
+    stream.on("error", (err) => {
         writeError = writeError ?? err;
     });
     return {
@@ -473,7 +474,7 @@ const openWriter = (target) => {
                 // `COPY FROM '/bind/mount/file'` can read a partial view even
                 // though the file is fully synced on the host. Linux + Windows
                 // bind mounts are coherent, so this branch is macOS-only.
-                if (platform() === 'darwin') {
+                if (platform() === "darwin") {
                     setTimeout(() => {
                         resolve({});
                     }, 25);
@@ -494,38 +495,38 @@ const openWriter = (target) => {
  */
 const errnoToStrerror = (err) => {
     switch (err.code) {
-        case 'ENOENT':
-            return 'No such file or directory';
-        case 'EACCES':
-            return 'Permission denied';
-        case 'EISDIR':
-            return 'Is a directory';
-        case 'ENOTDIR':
-            return 'Not a directory';
-        case 'EEXIST':
-            return 'File exists';
-        case 'EROFS':
-            return 'Read-only file system';
-        case 'ELOOP':
-            return 'Too many levels of symbolic links';
-        case 'ENAMETOOLONG':
-            return 'File name too long';
-        case 'ENOSPC':
-            return 'No space left on device';
-        case 'EMFILE':
-            return 'Too many open files';
-        case 'ENFILE':
-            return 'Too many open files in system';
-        case 'EIO':
-            return 'Input/output error';
-        case 'EFBIG':
-            return 'File too large';
-        case 'EDQUOT':
-            return 'Disk quota exceeded';
-        case 'EPERM':
-            return 'Operation not permitted';
-        case 'EINVAL':
-            return 'Invalid argument';
+        case "ENOENT":
+            return "No such file or directory";
+        case "EACCES":
+            return "Permission denied";
+        case "EISDIR":
+            return "Is a directory";
+        case "ENOTDIR":
+            return "Not a directory";
+        case "EEXIST":
+            return "File exists";
+        case "EROFS":
+            return "Read-only file system";
+        case "ELOOP":
+            return "Too many levels of symbolic links";
+        case "ENAMETOOLONG":
+            return "File name too long";
+        case "ENOSPC":
+            return "No space left on device";
+        case "EMFILE":
+            return "Too many open files";
+        case "ENFILE":
+            return "Too many open files in system";
+        case "EIO":
+            return "Input/output error";
+        case "EFBIG":
+            return "File too large";
+        case "EDQUOT":
+            return "Disk quota exceeded";
+        case "EPERM":
+            return "Operation not permitted";
+        case "EINVAL":
+            return "Invalid argument";
         default: {
             // Strip Node's `ENOENT: no such file or directory, open '/x'`
             // prefix when present so the fallback at least looks like the
@@ -557,7 +558,7 @@ const reportFileOpenFailure = (ctx, target, err) => {
     ctx.settings.lastErrorResult = { message: line };
     const prefix = psqlErrorPrefix(ctx.settings);
     writeErr(`${prefix}${line}\n`);
-    return { status: 'error', errorWritten: true };
+    return { status: "error", errorWritten: true };
 };
 /**
  * True when `err` was thrown by our synchronous `openSync` in
@@ -566,10 +567,10 @@ const reportFileOpenFailure = (ctx, target, err) => {
  * `\<cmd>: <msg>` path.
  */
 const isFileOpenFailure = (err) => {
-    if (!err || typeof err !== 'object')
+    if (!err || typeof err !== "object")
         return false;
     const e = err;
-    return typeof e.code === 'string' && e.code.startsWith('E');
+    return typeof e.code === "string" && e.code.startsWith("E");
 };
 /**
  * Format a child process exit code + signal into upstream psql's
@@ -595,9 +596,9 @@ const formatChildWaitResult = (exitCode, signal) => {
     if (exitCode === 0)
         return null;
     if (exitCode === 127)
-        return 'command not found';
+        return "command not found";
     if (exitCode === 126)
-        return 'command was not executable';
+        return "command was not executable";
     return `child process exited with exit code ${String(exitCode)}`;
 };
 /**
@@ -608,10 +609,10 @@ const formatChildWaitResult = (exitCode, signal) => {
  * available (e.g. `EmptyQueryResponse` carries `command = ''`).
  */
 const formatCommandTagText = (rs) => {
-    const command = (rs.command || '').trim();
+    const command = (rs.command || "").trim();
     if (command.length === 0)
-        return '';
-    if (command === 'INSERT') {
+        return "";
+    if (command === "INSERT") {
         // INSERT is the only tag with the legacy oid in front of rowCount.
         return `INSERT ${String(rs.oid ?? 0)} ${String(rs.rowCount ?? 0)}`;
     }
@@ -656,7 +657,9 @@ const renderResult = async (settings, rs, out) => {
         // For COPY-out results, the tag is suppressed regardless — the bytes
         // already flowed; upstream's `handleCopyOut` doesn't emit `COPY N`
         // on the queryFout.
-        if (!settings.popt.topt.tuplesOnly && !settings.quiet && !rs.copyOutBytes) {
+        if (!settings.popt.topt.tuplesOnly &&
+            !settings.quiet &&
+            !rs.copyOutBytes) {
             const tag = formatCommandTagText(rs);
             if (tag.length > 0)
                 out.write(`${tag}\n`);
@@ -675,24 +678,24 @@ const renderResult = async (settings, rs, out) => {
  */
 const pickActivePrinter = (settings) => {
     switch (settings.popt.topt.format) {
-        case 'aligned':
-        case 'wrapped':
+        case "aligned":
+        case "wrapped":
             return alignedPrinter;
-        case 'unaligned':
+        case "unaligned":
             return unalignedPrinter;
-        case 'csv':
+        case "csv":
             return csvPrinter;
-        case 'json':
+        case "json":
             return jsonPrinter;
-        case 'html':
+        case "html":
             return htmlPrinter;
-        case 'asciidoc':
+        case "asciidoc":
             return asciidocPrinter;
-        case 'latex':
+        case "latex":
             return latexPrinter;
-        case 'latex-longtable':
+        case "latex-longtable":
             return latexLongtablePrinter;
-        case 'troff-ms':
+        case "troff-ms":
             return troffMsPrinter;
         default:
             return alignedPrinter;
@@ -713,9 +716,9 @@ const pickOut = (settings, oneShot) => {
 // \i FILE / \include FILE
 // ---------------------------------------------------------------------------
 const runInclude = async (ctx, relative) => {
-    const arg = ctx.nextArg('normal');
+    const arg = ctx.nextArg("normal");
     if (arg === null || arg.length === 0) {
-        return errResult(ctx, 'missing required argument');
+        return errResult(ctx, "missing required argument");
     }
     // Resolve path: \ir resolves relative to the current input file's
     // directory (if any); \i resolves relative to cwd unless absolute.
@@ -731,7 +734,7 @@ const runInclude = async (ctx, relative) => {
     }
     let contents;
     try {
-        contents = await fsPromises.readFile(resolved, 'utf8');
+        contents = await fsPromises.readFile(resolved, "utf8");
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -744,11 +747,11 @@ const runInclude = async (ctx, relative) => {
     // -f/-c and (b) double-run interactively (the mainloop drains the queue
     // AND we run execSimple). See.
     if (!ctx.settings.db) {
-        return errResult(ctx, 'no connection to the server');
+        return errResult(ctx, "no connection to the server");
     }
     const trimmed = contents.trim();
     if (trimmed.length === 0) {
-        return { status: 'ok' };
+        return { status: "ok" };
     }
     // Track the prior inputfile so `\ir` chains relative to the included
     // file's directory.
@@ -760,7 +763,7 @@ const runInclude = async (ctx, relative) => {
         for (const rs of results) {
             await renderResult(ctx.settings, rs, out);
         }
-        return { status: 'ok' };
+        return { status: "ok" };
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
@@ -771,36 +774,36 @@ const runInclude = async (ctx, relative) => {
     }
 };
 export const cmdInclude = {
-    name: 'i',
-    aliases: ['include'],
-    helpKey: 'i',
+    name: "i",
+    aliases: ["include"],
+    helpKey: "i",
     run: (ctx) => runInclude(ctx, false),
 };
 export const cmdIncludeRel = {
-    name: 'ir',
-    aliases: ['include_relative'],
-    helpKey: 'ir',
+    name: "ir",
+    aliases: ["include_relative"],
+    helpKey: "ir",
     run: (ctx) => runInclude(ctx, true),
 };
 // ---------------------------------------------------------------------------
 // \o [FILE|cmd] / \out
 // ---------------------------------------------------------------------------
 export const cmdOut = {
-    name: 'o',
-    aliases: ['out'],
-    helpKey: 'o',
+    name: "o",
+    aliases: ["out"],
+    helpKey: "o",
     async run(ctx) {
-        const arg = ctx.nextArg('filepipe');
+        const arg = ctx.nextArg("filepipe");
         // Drain any previous target first so writes flush before we rebind.
         await closeQueryFout(ctx.settings);
         if (arg === null || arg.length === 0) {
             // Restore default (stdout).
-            return { status: 'ok' };
+            return { status: "ok" };
         }
         try {
             const entry = openWriter(arg);
             setQueryFout(ctx.settings, entry);
-            return { status: 'ok' };
+            return { status: "ok" };
         }
         catch (err) {
             // File targets fail synchronously in `openWriter` via `openSync`;
@@ -808,7 +811,7 @@ export const cmdOut = {
             // no `\o:` prefix) and continue with the loop so a follow-up
             // `SELECT` still executes. Pipe spawn failures (which lack an
             // errno code) fall through to the generic `\o: <msg>` path.
-            if (!arg.startsWith('|') && isFileOpenFailure(err)) {
+            if (!arg.startsWith("|") && isFileOpenFailure(err)) {
                 return reportFileOpenFailure(ctx, arg, err);
             }
             const msg = err instanceof Error ? err.message : String(err);
@@ -820,13 +823,13 @@ export const cmdOut = {
 // \w FILE / \write FILE
 // ---------------------------------------------------------------------------
 export const cmdWrite = {
-    name: 'w',
-    aliases: ['write'],
-    helpKey: 'w',
+    name: "w",
+    aliases: ["write"],
+    helpKey: "w",
     async run(ctx) {
-        const arg = ctx.nextArg('filepipe');
+        const arg = ctx.nextArg("filepipe");
         if (arg === null || arg.length === 0) {
-            return errResult(ctx, 'missing required argument');
+            return errResult(ctx, "missing required argument");
         }
         let entry;
         try {
@@ -837,7 +840,7 @@ export const cmdWrite = {
             // path errors out as a bare `<path>: <strerror>` line and the
             // shim keeps reading commands. Pipe spawn failures still use
             // the generic `\w: <msg>` envelope.
-            if (!arg.startsWith('|') && isFileOpenFailure(err)) {
+            if (!arg.startsWith("|") && isFileOpenFailure(err)) {
                 return reportFileOpenFailure(ctx, arg, err);
             }
             const msg = err instanceof Error ? err.message : String(err);
@@ -861,7 +864,8 @@ export const cmdWrite = {
             // status is what we want to report, NOT the write error — so we
             // swallow EPIPE on pipes and fall through to entry.close() which
             // awaits the child and emits the upstream-shape wait_result_to_str.
-            const isEpipe = err instanceof Error && err.code === 'EPIPE';
+            const isEpipe = err instanceof Error &&
+                err.code === "EPIPE";
             if (!entry.isPipe || !isEpipe) {
                 try {
                     await entry.close();
@@ -895,10 +899,10 @@ export const cmdWrite = {
                     ctx.settings.lastErrorResult = { message: line };
                     const prefix = psqlErrorPrefix(ctx.settings);
                     writeErr(`${prefix}${line}\n`);
-                    return { status: 'error', errorWritten: true };
+                    return { status: "error", errorWritten: true };
                 }
             }
-            return { status: 'ok' };
+            return { status: "ok" };
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
@@ -930,13 +934,13 @@ const parseGPsetOptions = (body) => {
             break;
         // Read option name up to `=`.
         const optStart = i;
-        while (i < body.length && body[i] !== '=' && !/\s/.test(body[i]))
+        while (i < body.length && body[i] !== "=" && !/\s/.test(body[i]))
             i++;
         const option = body.slice(optStart, i);
         if (option.length === 0)
             break;
-        let value = '';
-        if (body[i] === '=') {
+        let value = "";
+        if (body[i] === "=") {
             i++; // skip '='
             // Value: single-quoted or unquoted.
             if (body[i] === "'") {
@@ -946,16 +950,16 @@ const parseGPsetOptions = (body) => {
                     // C-style escapes (\n, \t, \\, \'). Mirror enough of the
                     // upstream `xslashquote` handling to round-trip the regress
                     // corpus.
-                    if (body[i] === '\\' && i + 1 < body.length) {
+                    if (body[i] === "\\" && i + 1 < body.length) {
                         const next = body[i + 1];
-                        if (next === 'n')
-                            value += '\n';
-                        else if (next === 't')
-                            value += '\t';
-                        else if (next === 'r')
-                            value += '\r';
-                        else if (next === '\\')
-                            value += '\\';
+                        if (next === "n")
+                            value += "\n";
+                        else if (next === "t")
+                            value += "\t";
+                        else if (next === "r")
+                            value += "\r";
+                        else if (next === "\\")
+                            value += "\\";
                         else if (next === "'")
                             value += "'";
                         else
@@ -1001,10 +1005,10 @@ const runGCore = async (ctx, forceExpanded) => {
     // arg block ourselves; otherwise fall back to normal filepipe arg
     // extraction.
     const rawTrimmed = ctx.rawArgs.trimStart();
-    if (rawTrimmed.startsWith('(')) {
-        const close = rawTrimmed.indexOf(')');
+    if (rawTrimmed.startsWith("(")) {
+        const close = rawTrimmed.indexOf(")");
         if (close === -1) {
-            return errResult(ctx, 'missing right parenthesis in \\g options');
+            return errResult(ctx, "missing right parenthesis in \\g options");
         }
         // Strip parens; parse `key=value` pairs (values may be single-
         // quoted). The conformance corpus exercises `format=`,
@@ -1017,7 +1021,7 @@ const runGCore = async (ctx, forceExpanded) => {
         target = afterParen.length > 0 ? afterParen : null;
     }
     else {
-        target = ctx.nextArg('filepipe');
+        target = ctx.nextArg("filepipe");
     }
     // `\g` / `\gx` with an empty buffer re-runs the most recently submitted
     // query — upstream tracks this in `pset.last_query` and `PSQLexec` reads
@@ -1035,10 +1039,10 @@ const runGCore = async (ctx, forceExpanded) => {
     if (sql.length === 0 && !hasPendingNamedBind) {
         // No buffered SQL, no prior query, no staged bind — silent no-op
         // like upstream.
-        return { status: 'reset-buf', newBuf: '' };
+        return { status: "reset-buf", newBuf: "" };
     }
     if (!ctx.settings.db) {
-        return errResult(ctx, 'no connection to the server');
+        return errResult(ctx, "no connection to the server");
     }
     // Open the one-shot writer if a target was supplied; close it on the way
     // out so the file/pipe is flushed before we return.
@@ -1055,7 +1059,7 @@ const runGCore = async (ctx, forceExpanded) => {
             // upstream's bare `<path>: <strerror>` shape and continue so the
             // next command in the script still executes. Pipe spawn
             // failures retain the generic `\g: <msg>` envelope.
-            if (!target.startsWith('|') && isFileOpenFailure(err)) {
+            if (!target.startsWith("|") && isFileOpenFailure(err)) {
                 return reportFileOpenFailure(ctx, target, err);
             }
             const msg = err instanceof Error ? err.message : String(err);
@@ -1069,7 +1073,7 @@ const runGCore = async (ctx, forceExpanded) => {
     // mutation would persist `expanded = 'on'` across queries.
     const toptSnapshot = { ...topt };
     if (forceExpanded)
-        topt.expanded = 'on';
+        topt.expanded = "on";
     // Apply per-query pset overrides silently. Upstream applies the
     // temporary options without emitting the status lines that
     // interactive `\pset` would.
@@ -1104,7 +1108,7 @@ const runGCore = async (ctx, forceExpanded) => {
                 // Synthesise a thrown-Error-like object so formatServerError can
                 // render the same `ERROR:  <msg>` shape vanilla emits for the
                 // server's `prepared statement "X" does not exist` error.
-                execError = Object.assign(new Error(`prepared statement "${bindState.name}" does not exist`), { severity: 'ERROR', code: '26000' });
+                execError = Object.assign(new Error(`prepared statement "${bindState.name}" does not exist`), { severity: "ERROR", code: "26000" });
             }
             else {
                 // Bind + Execute MUST go in one extended-protocol batch: the
@@ -1210,16 +1214,16 @@ const runGCore = async (ctx, forceExpanded) => {
     if (pipeError !== null) {
         return errResult(ctx, pipeError);
     }
-    return { status: 'reset-buf', newBuf: '' };
+    return { status: "reset-buf", newBuf: "" };
 };
 export const cmdG = {
-    name: 'g',
-    helpKey: 'g',
+    name: "g",
+    helpKey: "g",
     run: (ctx) => runGCore(ctx, false),
 };
 export const cmdGx = {
-    name: 'gx',
-    helpKey: 'gx',
+    name: "gx",
+    helpKey: "gx",
     run: (ctx) => runGCore(ctx, true),
 };
 // ---------------------------------------------------------------------------
@@ -1260,9 +1264,9 @@ export const cmdGx = {
  *    explicitly to match.
  */
 export const cmdPrint = {
-    name: 'p',
-    aliases: ['print'],
-    helpKey: 'p',
+    name: "p",
+    aliases: ["print"],
+    helpKey: "p",
     run: (ctx) => {
         // `queryBuf.trim()` for the emptiness check — not the printed text.
         // Upstream's `query_buf->len > 0` is a byte-length check that, in
@@ -1282,9 +1286,9 @@ export const cmdPrint = {
             writeOut(`${ctx.settings.lastQuery}\n`);
         }
         else if (!ctx.settings.quiet) {
-            writeOut('Query buffer is empty.\n');
+            writeOut("Query buffer is empty.\n");
         }
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 // ---------------------------------------------------------------------------
@@ -1292,14 +1296,14 @@ export const cmdPrint = {
 // ---------------------------------------------------------------------------
 const formatCell = (value) => {
     if (value === null || value === undefined)
-        return '';
-    if (typeof value === 'string')
+        return "";
+    if (typeof value === "string")
         return value;
     if (Buffer.isBuffer(value))
-        return value.toString('utf8');
-    if (typeof value === 'number' ||
-        typeof value === 'boolean' ||
-        typeof value === 'bigint') {
+        return value.toString("utf8");
+    if (typeof value === "number" ||
+        typeof value === "boolean" ||
+        typeof value === "bigint") {
         return String(value);
     }
     // Plain objects / arrays from JSON columns: JSON-stringify so the test
@@ -1308,12 +1312,12 @@ const formatCell = (value) => {
         return JSON.stringify(value);
     }
     catch {
-        return '';
+        return "";
     }
 };
 export const cmdGset = {
-    name: 'gset',
-    helpKey: 'gset',
+    name: "gset",
+    helpKey: "gset",
     async run(ctx) {
         const gated = pipelineGate(ctx);
         if (gated !== null)
@@ -1321,7 +1325,7 @@ export const cmdGset = {
         // Strip leading whitespace + comments — see runGCore for the rationale.
         const trimmedBuf = stripLeadingCommentsAndWS(ctx.queryBuf);
         const bufSql = trimmedBuf.trim();
-        const prefix = ctx.nextArg('normal') ?? '';
+        const prefix = ctx.nextArg("normal") ?? "";
         // Empty buffer behaviour mirrors upstream `exec_command_gset`'s
         // `PSQL_CMD_SEND` return: the dispatch loop sends the active
         // `pset.last_query` (or nothing). Upstream does NOT emit an error
@@ -1330,10 +1334,10 @@ export const cmdGset = {
         // dispatch.
         const sql = bufSql.length > 0 ? bufSql : ctx.settings.lastQuery.trim();
         if (sql.length === 0) {
-            return { status: 'reset-buf', newBuf: '' };
+            return { status: "reset-buf", newBuf: "" };
         }
         if (!ctx.settings.db) {
-            return errResult(ctx, 'no connection to the server');
+            return errResult(ctx, "no connection to the server");
         }
         // Track for a subsequent `\g` re-run with empty buffer. Upstream
         // `exec_command_gset` updates `pset.last_query` to the dispatched SQL
@@ -1379,29 +1383,29 @@ export const cmdGset = {
         // tuples-producing, skip the variable-assignment step entirely.
         const lastRs = results[results.length - 1];
         if (!lastRs || lastRs.fields.length === 0) {
-            return { status: 'reset-buf', newBuf: '' };
+            return { status: "reset-buf", newBuf: "" };
         }
         const rs = lastRs;
         if (rs.rows.length === 0) {
             // Bare `no rows returned for \gset` (no `\gset:` prefix) — matches
             // upstream psql's `pg_log_error("no rows returned for \\gset")`.
             ctx.settings.lastErrorResult = {
-                message: 'no rows returned for \\gset',
+                message: "no rows returned for \\gset",
             };
             const errPrefix = psqlErrorPrefix(ctx.settings);
             writeErr(`${errPrefix}no rows returned for \\gset\n`);
-            return { status: 'error', errorWritten: true };
+            return { status: "error", errorWritten: true };
         }
         if (rs.rows.length > 1) {
             // Match upstream psql's exact wording from `exec_command_gset` —
             // bare `more than one row returned for \gset` (no `\gset:` prefix).
             // Verified against vanilla psql; vendored psql.out emits it bare.
             ctx.settings.lastErrorResult = {
-                message: 'more than one row returned for \\gset',
+                message: "more than one row returned for \\gset",
             };
             const errPrefix = psqlErrorPrefix(ctx.settings);
             writeErr(`${errPrefix}more than one row returned for \\gset\n`);
-            return { status: 'error', errorWritten: true };
+            return { status: "error", errorWritten: true };
         }
         const row = rs.rows[0];
         for (let i = 0; i < rs.fields.length; i++) {
@@ -1450,10 +1454,10 @@ export const cmdGset = {
                 };
                 const errPrefix = psqlErrorPrefix(ctx.settings);
                 writeErr(`${errPrefix}invalid variable name: "${fieldName}"\n`);
-                return { status: 'error', errorWritten: true };
+                return { status: "error", errorWritten: true };
             }
         }
-        return { status: 'reset-buf', newBuf: '' };
+        return { status: "reset-buf", newBuf: "" };
     },
 };
 // ---------------------------------------------------------------------------
@@ -1496,7 +1500,7 @@ const buildGdescFormatQuery = (fields) => {
         const typmod = String(f.dataTypeModifier | 0);
         return `(${String(i)}, '${safeName}', ${oid}::oid, ${typmod}::int4)`;
     })
-        .join(', ');
+        .join(", ");
     // ORDER BY _idx preserves the describe order regardless of how the server
     // happens to evaluate the VALUES list. Aliases match upstream column
     // titles exactly so the printer header is identical.
@@ -1511,7 +1515,7 @@ const buildGdescFormatQuery = (fields) => {
  */
 const GDESC_SYNTHETIC_FIELDS = [
     {
-        name: 'Column',
+        name: "Column",
         tableID: 0,
         columnID: 0,
         dataTypeID: 25, // text
@@ -1520,7 +1524,7 @@ const GDESC_SYNTHETIC_FIELDS = [
         format: 0,
     },
     {
-        name: 'Type',
+        name: "Type",
         tableID: 0,
         columnID: 0,
         dataTypeID: 25, // text
@@ -1530,7 +1534,7 @@ const GDESC_SYNTHETIC_FIELDS = [
     },
 ];
 const buildSyntheticGdescResultSet = (rows) => ({
-    command: 'SELECT',
+    command: "SELECT",
     rowCount: rows.length,
     oid: null,
     fields: GDESC_SYNTHETIC_FIELDS,
@@ -1538,8 +1542,8 @@ const buildSyntheticGdescResultSet = (rows) => ({
     notices: [],
 });
 export const cmdGdesc = {
-    name: 'gdesc',
-    helpKey: 'gdesc',
+    name: "gdesc",
+    helpKey: "gdesc",
     async run(ctx) {
         const gated = pipelineGate(ctx);
         if (gated !== null)
@@ -1553,13 +1557,13 @@ export const cmdGdesc = {
             // `PrintQueryStatus`'s "The command has no result, or the result
             // has no columns." line. Stdout, exit 0 — not an error. Verified
             // against vanilla psql 18.
-            process.stdout.write('The command has no result, or the result has no columns.\n');
+            process.stdout.write("The command has no result, or the result has no columns.\n");
             // Match upstream's post-PSQL_CMD_SEND state vars: success, 0 rows.
-            refreshErrorVars(ctx.settings, { kind: 'success', rowCount: 0 });
-            return { status: 'reset-buf', newBuf: '' };
+            refreshErrorVars(ctx.settings, { kind: "success", rowCount: 0 });
+            return { status: "reset-buf", newBuf: "" };
         }
         if (!ctx.settings.db) {
-            return errResult(ctx, 'no connection to the server');
+            return errResult(ctx, "no connection to the server");
         }
         // Track for a subsequent `\g` re-run with empty buffer. Upstream
         // `exec_command_gdesc` updates `pset.last_query` to the dispatched SQL
@@ -1573,7 +1577,7 @@ export const cmdGdesc = {
         ctx.settings.lastQuery = sql;
         let fields;
         try {
-            const stmt = await ctx.settings.db.prepare('', sql);
+            const stmt = await ctx.settings.db.prepare("", sql);
             fields = await stmt.describe();
             // Close the unnamed prepared statement so we don't leak it. Failure
             // to close (e.g. server already in error state) is non-fatal.
@@ -1600,10 +1604,10 @@ export const cmdGdesc = {
         // Verified against vanilla psql 18: `SELECT \gdesc` and
         // `CREATE TABLE bububu(a int) \gdesc` both produce that text.
         if (fields.length === 0) {
-            process.stdout.write('The command has no result, or the result has no columns.\n');
+            process.stdout.write("The command has no result, or the result has no columns.\n");
             // Match upstream's post-PSQL_CMD_SEND state vars: success, 0 rows.
-            refreshErrorVars(ctx.settings, { kind: 'success', rowCount: 0 });
-            return { status: 'reset-buf', newBuf: '' };
+            refreshErrorVars(ctx.settings, { kind: "success", rowCount: 0 });
+            return { status: "reset-buf", newBuf: "" };
         }
         // Resolve canonical type names via a follow-up round trip when we have
         // at least one field. On failure (or when the server returns nothing —
@@ -1619,7 +1623,8 @@ export const cmdGdesc = {
             try {
                 const sets = await ctx.settings.db.execSimple(formatQuery);
                 const last = sets[sets.length - 1];
-                rows = last && last.rows.length > 0 ? last.rows : fallbackRows();
+                rows =
+                    last && last.rows.length > 0 ? last.rows : fallbackRows();
             }
             catch {
                 rows = fallbackRows();
@@ -1641,18 +1646,18 @@ export const cmdGdesc = {
         // `SetResultVariables` sees the synthetic 2-column tuple result and
         // assigns ROW_COUNT to the field count we just rendered.
         refreshErrorVars(ctx.settings, {
-            kind: 'success',
+            kind: "success",
             rowCount: rs.rowCount,
         });
-        return { status: 'reset-buf', newBuf: '' };
+        return { status: "reset-buf", newBuf: "" };
     },
 };
 // ---------------------------------------------------------------------------
 // \gexec — treat each cell of the result as SQL to execute.
 // ---------------------------------------------------------------------------
 export const cmdGexec = {
-    name: 'gexec',
-    helpKey: 'gexec',
+    name: "gexec",
+    helpKey: "gexec",
     async run(ctx) {
         const gated = pipelineGate(ctx);
         if (gated !== null)
@@ -1665,10 +1670,10 @@ export const cmdGexec = {
         // query — exit 0, no message. Verified against vanilla psql 18.
         const sql = bufSql.length > 0 ? bufSql : ctx.settings.lastQuery.trim();
         if (sql.length === 0) {
-            return { status: 'reset-buf', newBuf: '' };
+            return { status: "reset-buf", newBuf: "" };
         }
         if (!ctx.settings.db) {
-            return errResult(ctx, 'no connection to the server');
+            return errResult(ctx, "no connection to the server");
         }
         // Track the outer (meta) query for a subsequent `\g` re-run with an empty
         // buffer. Upstream `exec_command_gexec` runs through PSQL_CMD_SEND, which
@@ -1686,7 +1691,7 @@ export const cmdGexec = {
         }
         const tupled = firstPass.filter((r) => r.fields.length > 0);
         if (tupled.length === 0) {
-            return { status: 'reset-buf', newBuf: '' };
+            return { status: "reset-buf", newBuf: "" };
         }
         const out = pickOut(ctx.settings, null);
         // Echo each generated SQL when ECHO is `all` or `queries`. Vanilla
@@ -1696,7 +1701,7 @@ export const cmdGexec = {
         // appears BEFORE the result body so the conformance harness sees
         // the same interleaving vanilla produces.
         const echo = ctx.settings.echo;
-        const shouldEcho = echo === 'all' || echo === 'queries';
+        const shouldEcho = echo === "all" || echo === "queries";
         // Per-row errors are tolerated: upstream `\gexec` calls
         // `SendQuery` in a loop and ignores its return value (the only
         // escape is the global ON_ERROR_STOP variable, which the
@@ -1713,7 +1718,7 @@ export const cmdGexec = {
                     if (statement.length === 0)
                         continue;
                     if (shouldEcho) {
-                        out.write(statement + '\n');
+                        out.write(statement + "\n");
                     }
                     try {
                         const nested = await ctx.settings.db.execSimple(statement);
@@ -1735,7 +1740,7 @@ export const cmdGexec = {
                         // global `pset.on_error_stop` flag via `SendQuery`'s
                         // return; we mirror by checking the setting directly.
                         if (ctx.settings.onErrorStop) {
-                            return { status: 'error', errorWritten: true };
+                            return { status: "error", errorWritten: true };
                         }
                     }
                 }
@@ -1745,7 +1750,7 @@ export const cmdGexec = {
         // outer `\gexec` buffer. Per-row error rendering already happened;
         // returning `error` here would re-trigger the writeError path.
         void sawError;
-        return { status: 'reset-buf', newBuf: '' };
+        return { status: "reset-buf", newBuf: "" };
     },
 };
 // ---------------------------------------------------------------------------
@@ -1771,12 +1776,12 @@ export const cmdGexec = {
 // ---------------------------------------------------------------------------
 const sleepCancellable = (ms, signal) => new Promise((resolve) => {
     const timer = setTimeout(() => {
-        signal.removeEventListener('abort', onAbort);
+        signal.removeEventListener("abort", onAbort);
         resolve();
     }, ms);
     const onAbort = () => {
         clearTimeout(timer);
-        signal.removeEventListener('abort', onAbort);
+        signal.removeEventListener("abort", onAbort);
         resolve();
     };
     if (signal.aborted) {
@@ -1784,7 +1789,7 @@ const sleepCancellable = (ms, signal) => new Promise((resolve) => {
         resolve();
         return;
     }
-    signal.addEventListener('abort', onAbort);
+    signal.addEventListener("abort", onAbort);
 });
 /**
  * Strictly parse a non-negative finite float.
@@ -1834,7 +1839,7 @@ const parseStrictNonNegativeInt = (raw) => {
  * it when the user unsets the `WATCH_INTERVAL` variable — upstream's
  * `watch_interval_substitute_hook` reseeds the value to `2` on null.
  */
-export const DEFAULT_WATCH_INTERVAL = '2';
+export const DEFAULT_WATCH_INTERVAL = "2";
 /**
  * Render `\watch`'s per-iteration timestamp in upstream psql's
  * `ctime`-style layout: `Day Mon DD HH:MM:SS YYYY` (e.g. `Mon May 25
@@ -1844,20 +1849,20 @@ export const DEFAULT_WATCH_INTERVAL = '2';
  *
  * Exported only for unit-testing the format ladder.
  */
-const WEEKDAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+const WEEKDAYS = ["Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat"];
 const MONTHS = [
-    'Jan',
-    'Feb',
-    'Mar',
-    'Apr',
-    'May',
-    'Jun',
-    'Jul',
-    'Aug',
-    'Sep',
-    'Oct',
-    'Nov',
-    'Dec',
+    "Jan",
+    "Feb",
+    "Mar",
+    "Apr",
+    "May",
+    "Jun",
+    "Jul",
+    "Aug",
+    "Sep",
+    "Oct",
+    "Nov",
+    "Dec",
 ];
 const pad2 = (n) => (n < 10 ? `0${String(n)}` : String(n));
 export const formatWatchTimestamp = (now) => {
@@ -1890,7 +1895,7 @@ const resolveWatchIntervalDefault = (settings) => {
     // If a future code path leaves it undefined we fall back to the same
     // documented default — upstream's `ParseVariableDouble` substitutes
     // `DEFAULT_WATCH_INTERVAL` when the var slot is empty.
-    const raw = settings.vars.get('WATCH_INTERVAL') ?? DEFAULT_WATCH_INTERVAL;
+    const raw = settings.vars.get("WATCH_INTERVAL") ?? DEFAULT_WATCH_INTERVAL;
     const parsed = parseStrictNonNegativeFloat(raw);
     if (parsed === null || parsed > WATCH_INTERVAL_MAX_SECONDS) {
         return {
@@ -1925,14 +1930,14 @@ const resolveWatchIntervalDefault = (settings) => {
  * output target.
  */
 const openWatchPager = () => {
-    const cmd = process.env.PSQL_WATCH_PAGER ?? '';
+    const cmd = process.env.PSQL_WATCH_PAGER ?? "";
     if (cmd.trim().length === 0)
         return null;
-    const child = spawn('sh', ['-c', cmd], {
-        stdio: ['pipe', 'inherit', 'inherit'],
+    const child = spawn("sh", ["-c", cmd], {
+        stdio: ["pipe", "inherit", "inherit"],
     });
-    child.stdin.on('error', (err) => {
-        if (err.code !== 'EPIPE') {
+    child.stdin.on("error", (err) => {
+        if (err.code !== "EPIPE") {
             throw err;
         }
     });
@@ -1954,15 +1959,15 @@ const openWatchPager = () => {
                 settled = true;
                 resolve();
             };
-            child.once('close', finish);
-            child.once('error', finish);
+            child.once("close", finish);
+            child.once("error", finish);
             if (!child.stdin.destroyed) {
                 try {
                     child.stdin.end();
                 }
                 catch (err) {
                     const e = err;
-                    if (e.code !== 'EPIPE')
+                    if (e.code !== "EPIPE")
                         finish();
                 }
             }
@@ -1970,8 +1975,8 @@ const openWatchPager = () => {
     };
 };
 export const cmdWatch = {
-    name: 'watch',
-    helpKey: 'watch',
+    name: "watch",
+    helpKey: "watch",
     async run(ctx) {
         const gated = pipelineGate(ctx);
         if (gated !== null)
@@ -1980,10 +1985,10 @@ export const cmdWatch = {
         const trimmedBuf = stripLeadingCommentsAndWS(ctx.queryBuf);
         const sql = trimmedBuf.trim();
         if (sql.length === 0) {
-            return errResult(ctx, 'no query buffer');
+            return errResult(ctx, "no query buffer");
         }
         if (!ctx.settings.db) {
-            return errResult(ctx, 'no connection to the server');
+            return errResult(ctx, "no connection to the server");
         }
         // Track which options have been seen so we can reject duplicates with
         // the upstream-formatted "<thing> is specified more than once" message.
@@ -1997,7 +2002,7 @@ export const cmdWatch = {
         // Drain all args. Each is either a `key=value` token or a bare
         // positional (only allowed as the very first arg, and only once).
         while (true) {
-            const arg = ctx.nextArg('normal');
+            const arg = ctx.nextArg("normal");
             if (arg === null)
                 break;
             if (arg.length === 0)
@@ -2005,25 +2010,26 @@ export const cmdWatch = {
             // Identify named flags by looking for `=`. Upstream tolerates an
             // empty value (treats it as the option not being provided), but we
             // mirror its stricter behaviour for the values we care about.
-            const eqIdx = arg.indexOf('=');
+            const eqIdx = arg.indexOf("=");
             if (eqIdx > 0) {
                 const key = arg.slice(0, eqIdx);
                 const value = arg.slice(eqIdx + 1);
-                if (key === 'i') {
+                if (key === "i") {
                     if (intervalSet) {
-                        return errResult(ctx, 'interval value is specified more than once');
+                        return errResult(ctx, "interval value is specified more than once");
                     }
                     const parsed = parseStrictNonNegativeFloat(value);
-                    if (parsed === null || parsed > WATCH_INTERVAL_MAX_SECONDS) {
+                    if (parsed === null ||
+                        parsed > WATCH_INTERVAL_MAX_SECONDS) {
                         return errResult(ctx, `incorrect interval value "${value}"`);
                     }
                     interval = parsed;
                     intervalSet = true;
                     continue;
                 }
-                if (key === 'c') {
+                if (key === "c") {
                     if (iterSet) {
-                        return errResult(ctx, 'iteration count is specified more than once');
+                        return errResult(ctx, "iteration count is specified more than once");
                     }
                     const parsed = parseStrictNonNegativeInt(value);
                     // Upstream parses the count with `option_parse_int(..., 1, INT_MAX)`
@@ -2038,9 +2044,9 @@ export const cmdWatch = {
                     iterSet = true;
                     continue;
                 }
-                if (key === 'm' || key === 'min_rows') {
+                if (key === "m" || key === "min_rows") {
                     if (minRowsSet) {
-                        return errResult(ctx, 'minimum row count specified more than once');
+                        return errResult(ctx, "minimum row count specified more than once");
                     }
                     const parsed = parseStrictNonNegativeInt(value);
                     if (parsed === null) {
@@ -2058,7 +2064,7 @@ export const cmdWatch = {
             // only collides with `i=` under the same upstream "specified more
             // than once" rubric.
             if (positionalSeen || intervalSet) {
-                return errResult(ctx, 'interval value is specified more than once');
+                return errResult(ctx, "interval value is specified more than once");
             }
             const parsed = parseStrictNonNegativeFloat(arg);
             if (parsed === null || parsed > WATCH_INTERVAL_MAX_SECONDS) {
@@ -2071,7 +2077,7 @@ export const cmdWatch = {
         // If no explicit interval was supplied, fall back to WATCH_INTERVAL.
         if (interval === null) {
             const resolved = resolveWatchIntervalDefault(ctx.settings);
-            if ('error' in resolved) {
+            if ("error" in resolved) {
                 return errResult(ctx, resolved.error);
             }
             interval = resolved.value;
@@ -2085,7 +2091,7 @@ export const cmdWatch = {
         };
         const installedSigint = WATCH_TEST_CONTROLLER.ref === null;
         if (installedSigint) {
-            process.once('SIGINT', sigintHandler);
+            process.once("SIGINT", sigintHandler);
         }
         // Open the pager once for the whole loop (upstream `do_watch` wraps the
         // entire session, not each iteration, so the user can scroll the
@@ -2152,13 +2158,13 @@ export const cmdWatch = {
             // possible `^C` echo. Mirror that here so the conformance output
             // shape (`...\n(N rows)\n\n\n`) matches vanilla psql.
             if (!pager) {
-                out.write('\n');
+                out.write("\n");
             }
-            return { status: 'reset-buf', newBuf: '' };
+            return { status: "reset-buf", newBuf: "" };
         }
         finally {
             if (installedSigint) {
-                process.removeListener('SIGINT', sigintHandler);
+                process.removeListener("SIGINT", sigintHandler);
             }
             // Drain the pager so its child has a chance to exit before \watch
             // returns. Failures are swallowed: a broken pager shouldn't mask the