neonctl 2.28.0 → 2.29.0

package/dist/psql/command/cmd_pipeline.js

@@ -32,16 +32,16 @@
  *
  * The set is registered in bulk via {@link registerPipelineCommands}.
  */
-import { writeErr } from './shared.js';
-import { alignedPrinter } from '../print/aligned.js';
-import { clearPipelineGateErrors } from './cmd_io.js';
+import { alignedPrinter } from "../print/aligned.js";
+import { clearPipelineGateErrors } from "./cmd_io.js";
+import { writeErr } from "./shared.js";
 // ---------------------------------------------------------------------------
 // Settings stash. We can't add new fields to PsqlSettings (frozen WP-00) so
 // we attach Symbol-keyed state.
 // ---------------------------------------------------------------------------
-const BIND_STATE_KEY = Symbol.for('neonctl.psql.bindState');
-const PIPELINE_KEY = Symbol.for('neonctl.psql.pipeline');
-const PREPARED_BY_NAME_KEY = Symbol.for('neonctl.psql.preparedByName');
+const BIND_STATE_KEY = Symbol.for("neonctl.psql.bindState");
+const PIPELINE_KEY = Symbol.for("neonctl.psql.pipeline");
+const PREPARED_BY_NAME_KEY = Symbol.for("neonctl.psql.preparedByName");
 const stashOf = (settings) => settings;
 /** Read (and clear) the pending bind params, if any. */
 export const consumeBindState = (settings) => {
@@ -128,9 +128,9 @@ const bumpCounter = (settings, name, delta) => {
     setCounter(settings, name, readCounter(settings, name) + delta);
 };
 const resetPipelineCounters = (settings) => {
-    setCounter(settings, 'PIPELINE_COMMAND_COUNT', 0);
-    setCounter(settings, 'PIPELINE_SYNC_COUNT', 0);
-    setCounter(settings, 'PIPELINE_RESULT_COUNT', 0);
+    setCounter(settings, "PIPELINE_COMMAND_COUNT", 0);
+    setCounter(settings, "PIPELINE_SYNC_COUNT", 0);
+    setCounter(settings, "PIPELINE_RESULT_COUNT", 0);
 };
 /**
  * Wrap `Pipeline.execute` so each enqueued Execute message bumps
@@ -146,7 +146,7 @@ const resetPipelineCounters = (settings) => {
 const wrapSessionForCounters = (session, settings) => {
     const origExecute = session.execute.bind(session);
     session.execute = (name, maxRows) => {
-        bumpCounter(settings, 'PIPELINE_COMMAND_COUNT', 1);
+        bumpCounter(settings, "PIPELINE_COMMAND_COUNT", 1);
         return origExecute(name, maxRows);
     };
     return session;
@@ -159,7 +159,7 @@ const errResult = (ctx, message) => {
     writeErr(`\\${ctx.cmdName}: ${message}\n`);
     // Tell mainloop the diagnostic is already on stderr so it doesn't add
     // a `psql: ERROR:  <msg>` fallback line.
-    return { status: 'error', errorWritten: true };
+    return { status: "error", errorWritten: true };
 };
 /**
  * Coerce any thrown / rejected value into a printable string. The
@@ -175,9 +175,9 @@ const errorToMessage = (err) => {
     if (err instanceof Error)
         return err.message;
     if (err !== null &&
-        typeof err === 'object' &&
-        'message' in err &&
-        typeof err.message === 'string') {
+        typeof err === "object" &&
+        "message" in err &&
+        typeof err.message === "string") {
         return err.message;
     }
     try {
@@ -200,7 +200,7 @@ const errorToMessage = (err) => {
  * the originating SQL position through `session.lastError`.
  */
 const renderPipelineError = (err) => {
-    if (err === null || typeof err !== 'object') {
+    if (err === null || typeof err !== "object") {
         writeErr(`ERROR:  ${errorToMessage(err)}\n`);
         return;
     }
@@ -211,11 +211,11 @@ const renderPipelineError = (err) => {
     // wording the regress baseline asserts for cascaded skips after a
     // preceding ErrorResponse.
     if (e.pipelineAborted) {
-        writeErr(`${e.message ?? 'Pipeline aborted, command did not run'}\n`);
+        writeErr(`${e.message ?? "Pipeline aborted, command did not run"}\n`);
         return;
     }
-    const severity = e.severity ?? 'ERROR';
-    const message = e.message ?? '';
+    const severity = e.severity ?? "ERROR";
+    const message = e.message ?? "";
     writeErr(`${severity}:  ${message}\n`);
     if (e.detail)
         writeErr(`DETAIL:  ${e.detail}\n`);
@@ -227,7 +227,7 @@ const renderPipelineError = (err) => {
 const readAllArgs = (ctx) => {
     const out = [];
     for (;;) {
-        const arg = ctx.nextArg('normal');
+        const arg = ctx.nextArg("normal");
         if (arg === null)
             break;
         out.push(arg);
@@ -238,26 +238,26 @@ const readAllArgs = (ctx) => {
 // \bind [VALUE ...]
 // ---------------------------------------------------------------------------
 export const cmdBind = {
-    name: 'bind',
-    helpKey: 'bind',
+    name: "bind",
+    helpKey: "bind",
     run(ctx) {
         const values = readAllArgs(ctx);
         stashOf(ctx.settings)[BIND_STATE_KEY] = {
-            name: '',
+            name: "",
             values,
             byName: false,
         };
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 // ---------------------------------------------------------------------------
 // \bind_named NAME [VALUE ...]
 // ---------------------------------------------------------------------------
 export const cmdBindNamed = {
-    name: 'bind_named',
-    helpKey: 'bind_named',
+    name: "bind_named",
+    helpKey: "bind_named",
     run(ctx) {
-        const name = ctx.nextArg('normal');
+        const name = ctx.nextArg("normal");
         // Upstream `exec_command_bind_named` rejects only the missing-arg
         // case. `''` IS valid — it addresses the unnamed prepared statement
         // slot (set via `\parse ''`).
@@ -266,27 +266,27 @@ export const cmdBindNamed = {
             // follow-on `\g` falls back to `pset.last_query` (the previous
             // successful query) instead of executing against a stale handle.
             stashOf(ctx.settings)[BIND_STATE_KEY] = undefined;
-            return Promise.resolve(errResult(ctx, 'missing required argument'));
+            return Promise.resolve(errResult(ctx, "missing required argument"));
         }
         const values = readAllArgs(ctx);
         stashOf(ctx.settings)[BIND_STATE_KEY] = { name, values, byName: true };
-        return Promise.resolve({ status: 'ok' });
+        return Promise.resolve({ status: "ok" });
     },
 };
 // ---------------------------------------------------------------------------
 // \parse NAME — prepare current queryBuf as NAME.
 // ---------------------------------------------------------------------------
 export const cmdParse = {
-    name: 'parse',
-    helpKey: 'parse',
+    name: "parse",
+    helpKey: "parse",
     async run(ctx) {
-        const name = ctx.nextArg('normal');
+        const name = ctx.nextArg("normal");
         // Upstream `exec_command_parse` rejects only the missing-arg case
         // with `missing required argument`. An explicit empty string `''`
         // IS valid — it's the "unnamed" prepared statement slot, addressable
         // later via `\bind_named ''`.
         if (name === null) {
-            return errResult(ctx, 'missing required argument');
+            return errResult(ctx, "missing required argument");
         }
         // Upstream `exec_command_parse` passes the query buffer verbatim to
         // `PQsendPrepare`, with no trim — the server then stores the bytes
@@ -297,10 +297,10 @@ export const cmdParse = {
         // only buffer reports `no query buffer` like upstream does.
         const sql = ctx.queryBuf;
         if (sql.trim().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");
         }
         // In pipeline mode, route the Parse through the active session so
         // it gets queued behind the in-flight P/B/E ops (and the server
@@ -321,7 +321,7 @@ export const cmdParse = {
                 // accounting. Test mocks that don't implement `parseSlot` fall
                 // through to the plain `parse()` method.
                 const session = pipelineActive.session;
-                if (typeof session.parseSlot === 'function') {
+                if (typeof session.parseSlot === "function") {
                     await session.parseSlot(name, sql, []);
                 }
                 else {
@@ -330,8 +330,8 @@ export const cmdParse = {
                 ctx.settings.lastQuery = sql;
                 // Upstream `exec_command_parse` bumps `pset.piped_commands` after
                 // PQsendPrepare succeeds — the Parse is one queued command.
-                bumpCounter(ctx.settings, 'PIPELINE_COMMAND_COUNT', 1);
-                return { status: 'reset-buf', newBuf: '' };
+                bumpCounter(ctx.settings, "PIPELINE_COMMAND_COUNT", 1);
+                return { status: "reset-buf", newBuf: "" };
             }
             catch (err) {
                 return errResult(ctx, errorToMessage(err));
@@ -352,7 +352,7 @@ export const cmdParse = {
             // "ERROR: there is no parameter $1" the conformance corpus
             // expects from `SELECT $1, $2` executed without bind params.
             ctx.settings.lastQuery = sql;
-            return { status: 'reset-buf', newBuf: '' };
+            return { status: "reset-buf", newBuf: "" };
         }
         catch (err) {
             return errResult(ctx, errorToMessage(err));
@@ -363,17 +363,17 @@ export const cmdParse = {
 // \close_prepared NAME
 // ---------------------------------------------------------------------------
 export const cmdClosePrepared = {
-    name: 'close_prepared',
-    helpKey: 'close_prepared',
+    name: "close_prepared",
+    helpKey: "close_prepared",
     async run(ctx) {
-        const name = ctx.nextArg('normal');
+        const name = ctx.nextArg("normal");
         // Empty string `''` is the valid unnamed prepared statement.
         if (name === null) {
-            return errResult(ctx, 'missing required argument');
+            return errResult(ctx, "missing required argument");
         }
         const db = ctx.settings.db;
         if (!db) {
-            return errResult(ctx, 'no connection to the server');
+            return errResult(ctx, "no connection to the server");
         }
         // Inside an open pipeline, upstream routes through
         // `PQsendClosePrepared` (queues a `Close('S', name)` behind the
@@ -391,7 +391,7 @@ export const cmdClosePrepared = {
                 // that don't implement `closeSlot` fall through to plain
                 // `close()`.
                 const session = ps.session;
-                if (typeof session.closeSlot === 'function') {
+                if (typeof session.closeSlot === "function") {
                     await session.closeSlot(name);
                 }
                 else {
@@ -399,11 +399,11 @@ export const cmdClosePrepared = {
                 }
                 // Upstream `exec_command_close_prepared` bumps `piped_commands`
                 // (PIPELINE_COMMAND_COUNT) after a successful PQsendClosePrepared.
-                bumpCounter(ctx.settings, 'PIPELINE_COMMAND_COUNT', 1);
+                bumpCounter(ctx.settings, "PIPELINE_COMMAND_COUNT", 1);
                 // Drop any cached binding so a later `\bind_named NAME \g`
                 // errors cleanly instead of using a stale handle.
                 dropPrepared(ctx.settings, name);
-                return { status: 'ok' };
+                return { status: "ok" };
             }
             catch (err) {
                 return errResult(ctx, errorToMessage(err));
@@ -425,13 +425,13 @@ export const cmdClosePrepared = {
                 // implement the dedicated entry point. The real PgConnection
                 // always provides closePreparedStatement; this branch only
                 // fires under unit tests with bespoke Connection mocks.
-                const stmt = await db.prepare(name, 'SELECT 1');
+                const stmt = await db.prepare(name, "SELECT 1");
                 await stmt.close();
             }
             // Drop any cached binding so a later `\bind_named NAME \g` errors
             // cleanly instead of using a stale handle.
             dropPrepared(ctx.settings, name);
-            return { status: 'ok' };
+            return { status: "ok" };
         }
         catch (err) {
             return errResult(ctx, errorToMessage(err));
@@ -442,11 +442,11 @@ export const cmdClosePrepared = {
 // \startpipeline / \endpipeline
 // ---------------------------------------------------------------------------
 export const cmdStartPipeline = {
-    name: 'startpipeline',
-    helpKey: 'startpipeline',
+    name: "startpipeline",
+    helpKey: "startpipeline",
     run(ctx) {
         if (!ctx.settings.db) {
-            return Promise.resolve(errResult(ctx, 'no connection to the server'));
+            return Promise.resolve(errResult(ctx, "no connection to the server"));
         }
         // Vanilla psql 18.4 treats a duplicate `\startpipeline` as a silent
         // no-op (no warning on stdout OR stderr) — verified empirically:
@@ -455,7 +455,7 @@ export const cmdStartPipeline = {
         // lines. Our prior `errResult('pipeline already active')` was a
         // divergence; match upstream's quiet path.
         if (getPipelineState(ctx.settings) !== null) {
-            return Promise.resolve({ status: 'ok' });
+            return Promise.resolve({ status: "ok" });
         }
         try {
             const session = wrapSessionForCounters(ctx.settings.db.pipeline(), ctx.settings);
@@ -464,11 +464,11 @@ export const cmdStartPipeline = {
                 pending: [],
                 drainedCount: 0,
             };
-            ctx.settings.sendMode = 'extended-pipeline';
+            ctx.settings.sendMode = "extended-pipeline";
             // Upstream `exec_command_startpipeline` calls SetVariable for the three
             // counter vars (zeroing whatever the prior pipeline left behind).
             resetPipelineCounters(ctx.settings);
-            return Promise.resolve({ status: 'ok' });
+            return Promise.resolve({ status: "ok" });
         }
         catch (err) {
             return Promise.resolve(errResult(ctx, errorToMessage(err)));
@@ -476,8 +476,8 @@ export const cmdStartPipeline = {
     },
 };
 export const cmdEndPipeline = {
-    name: 'endpipeline',
-    helpKey: 'endpipeline',
+    name: "endpipeline",
+    helpKey: "endpipeline",
     async run(ctx) {
         const ps = getPipelineState(ctx.settings);
         if (!ps) {
@@ -490,10 +490,10 @@ export const cmdEndPipeline = {
             // `errResult` (which would inject `\endpipeline: `) and write
             // the line directly.
             ctx.settings.lastErrorResult = {
-                message: 'cannot send pipeline when not in pipeline mode',
+                message: "cannot send pipeline when not in pipeline mode",
             };
-            writeErr('cannot send pipeline when not in pipeline mode\n');
-            return { status: 'error', errorWritten: true };
+            writeErr("cannot send pipeline when not in pipeline mode\n");
+            return { status: "error", errorWritten: true };
         }
         try {
             // Snapshot how many slots were already surfaced by prior
@@ -522,10 +522,10 @@ export const cmdEndPipeline = {
             // "fetching results in chunked mode failed" wording in lieu of
             // (or in addition to) the regular Pipeline aborted line. Read
             // BEFORE end() resets the counters.
-            const fetchCountActive = (ctx.settings.vars.get('FETCH_COUNT') ?? '0') !== '0';
+            const fetchCountActive = (ctx.settings.vars.get("FETCH_COUNT") ?? "0") !== "0";
             const sets = await ps.session.end();
             stashOf(ctx.settings)[PIPELINE_KEY] = undefined;
-            ctx.settings.sendMode = 'extended-query';
+            ctx.settings.sendMode = "extended-query";
             // Upstream `exec_command_endpipeline` zeroes the counters once the
             // pipeline has drained — mirrors the empirical behaviour of vanilla
             // psql 18.4 where `\echo :PIPELINE_*` reads "0" after `\endpipeline`.
@@ -554,7 +554,7 @@ export const cmdEndPipeline = {
             const entries = settled.length > 0
                 ? settled
                 : sets.map((rs) => ({
-                    status: 'fulfilled',
+                    status: "fulfilled",
                     value: rs,
                 }));
             // Pre-scan THIS slice (entries from `alreadyDrained` onward) for
@@ -570,12 +570,13 @@ export const cmdEndPipeline = {
             const sliceForError = entries.slice(alreadyDrained);
             const realFromSlice = (() => {
                 for (const r of sliceForError) {
-                    if (r.status !== 'rejected')
+                    if (r.status !== "rejected")
                         continue;
                     const reason = r.reason;
-                    const isAborted = typeof reason === 'object' &&
+                    const isAborted = typeof reason === "object" &&
                         reason !== null &&
-                        reason.pipelineAborted === true;
+                        reason
+                            .pipelineAborted === true;
                     if (!isAborted)
                         return reason;
                 }
@@ -586,7 +587,7 @@ export const cmdEndPipeline = {
                     const le = session.lastError;
                     if (le === null || le === undefined)
                         return null;
-                    if (typeof le === 'object' &&
+                    if (typeof le === "object" &&
                         le.pipelineAborted) {
                         return null;
                     }
@@ -594,7 +595,7 @@ export const cmdEndPipeline = {
                 })();
             for (let i = alreadyDrained; i < entries.length; i++) {
                 const r = entries[i];
-                if (r.status === 'fulfilled') {
+                if (r.status === "fulfilled") {
                     const rs = r.value;
                     // Emit any NoticeResponse messages attached to this result
                     // to stderr in the upstream libpq shape
@@ -622,8 +623,12 @@ export const cmdEndPipeline = {
                     // Skip our internal Sync marker (empty `command`, see
                     // wire/pipeline.ts) and DDL-style CommandComplete-only sets
                     // (non-empty `command` but no fields and no rows).
-                    const isSyncOrPlaceholder = rs.fields.length === 0 && rs.command === '' && rs.rows.length === 0;
-                    const isCommandOnly = rs.fields.length === 0 && rs.rows.length === 0 && rs.command !== '';
+                    const isSyncOrPlaceholder = rs.fields.length === 0 &&
+                        rs.command === "" &&
+                        rs.rows.length === 0;
+                    const isCommandOnly = rs.fields.length === 0 &&
+                        rs.rows.length === 0 &&
+                        rs.command !== "";
                     if (!isSyncOrPlaceholder && !isCommandOnly) {
                         if (rs.fields.length === 0 && rs.rows.length > 0) {
                             // 0-column tuples result: the aligned printer's
@@ -634,8 +639,8 @@ export const cmdEndPipeline = {
                             // `\watch`-rejected SELECT output byte-for-byte.
                             const tuplesOnly = ctx.settings.popt.topt.tuplesOnly;
                             if (!tuplesOnly) {
-                                process.stdout.write('--\n');
-                                process.stdout.write(`(${rs.rows.length} ${rs.rows.length === 1 ? 'row' : 'rows'})\n\n`);
+                                process.stdout.write("--\n");
+                                process.stdout.write(`(${rs.rows.length} ${rs.rows.length === 1 ? "row" : "rows"})\n\n`);
                             }
                         }
                         else {
@@ -653,9 +658,10 @@ export const cmdEndPipeline = {
                     // `session.lastError` / `peekRealError` for the original
                     // ERROR.
                     const reason = r.reason;
-                    const isAborted = typeof reason === 'object' &&
+                    const isAborted = typeof reason === "object" &&
                         reason !== null &&
-                        reason.pipelineAborted === true;
+                        reason
+                            .pipelineAborted === true;
                     // FETCH_COUNT-in-pipeline: upstream emits the chunked-mode
                     // diagnostic in addition to the per-op line. Both go to
                     // stderr; the chunked-mode line comes FIRST and addresses the
@@ -669,13 +675,13 @@ export const cmdEndPipeline = {
                     // aborted, command did not run" is shown ONLY for the synthetic
                     // queue-skip marker (no real error behind it).
                     if (fetchCountActive) {
-                        writeErr('fetching results in chunked mode failed\n');
+                        writeErr("fetching results in chunked mode failed\n");
                     }
                     if (isAborted && realLastError !== null) {
                         renderPipelineError(realLastError);
                     }
                     else if (isAborted) {
-                        writeErr('Pipeline aborted, command did not run\n');
+                        writeErr("Pipeline aborted, command did not run\n");
                     }
                     else {
                         renderPipelineError(reason);
@@ -694,16 +700,16 @@ export const cmdEndPipeline = {
                     // FETCH_COUNT was active, but still render the actual ERROR rather
                     // than the synthetic "Pipeline aborted" line (review: minor).
                     if (fetchCountActive) {
-                        writeErr('fetching results in chunked mode failed\n');
+                        writeErr("fetching results in chunked mode failed\n");
                     }
                     renderPipelineError(lastErr);
                 }
             }
-            return { status: 'ok' };
+            return { status: "ok" };
         }
         catch (err) {
             stashOf(ctx.settings)[PIPELINE_KEY] = undefined;
-            ctx.settings.sendMode = 'extended-query';
+            ctx.settings.sendMode = "extended-query";
             // Even on a failed `\endpipeline` (e.g. server hung up mid-drain),
             // mirror upstream and clear the counters — the pipeline state is
             // gone, so any non-zero value would be misleading. Same for the
@@ -718,12 +724,12 @@ export const cmdEndPipeline = {
 // \syncpipeline / \flushrequest / \flush
 // ---------------------------------------------------------------------------
 export const cmdSyncPipeline = {
-    name: 'syncpipeline',
-    helpKey: 'syncpipeline',
+    name: "syncpipeline",
+    helpKey: "syncpipeline",
     async run(ctx) {
         const ps = getPipelineState(ctx.settings);
         if (!ps)
-            return errResult(ctx, 'no pipeline active');
+            return errResult(ctx, "no pipeline active");
         try {
             await ps.session.sync();
             // Upstream `exec_command_syncpipeline`:
@@ -732,11 +738,11 @@ export const cmdSyncPipeline = {
             //   piped_syncs++;
             // The pending commands have transitioned to "queued results" on the
             // server, and Sync is itself counted as a piped command boundary.
-            const queued = readCounter(ctx.settings, 'PIPELINE_COMMAND_COUNT');
-            setCounter(ctx.settings, 'PIPELINE_COMMAND_COUNT', 0);
-            bumpCounter(ctx.settings, 'PIPELINE_RESULT_COUNT', queued);
-            bumpCounter(ctx.settings, 'PIPELINE_SYNC_COUNT', 1);
-            return { status: 'ok' };
+            const queued = readCounter(ctx.settings, "PIPELINE_COMMAND_COUNT");
+            setCounter(ctx.settings, "PIPELINE_COMMAND_COUNT", 0);
+            bumpCounter(ctx.settings, "PIPELINE_RESULT_COUNT", queued);
+            bumpCounter(ctx.settings, "PIPELINE_SYNC_COUNT", 1);
+            return { status: "ok" };
         }
         catch (err) {
             return errResult(ctx, errorToMessage(err));
@@ -744,22 +750,22 @@ export const cmdSyncPipeline = {
     },
 };
 export const cmdFlushRequest = {
-    name: 'flushrequest',
-    helpKey: 'flushrequest',
+    name: "flushrequest",
+    helpKey: "flushrequest",
     async run(ctx) {
         const ps = getPipelineState(ctx.settings);
         if (!ps)
-            return errResult(ctx, 'no pipeline active');
+            return errResult(ctx, "no pipeline active");
         try {
             await ps.session.flush();
             // Upstream `exec_command_flushrequest`:
             //   piped_results += piped_commands;
             //   piped_commands = 0;
             // The pending commands move to "queued results" but SYNC isn't issued.
-            const queued = readCounter(ctx.settings, 'PIPELINE_COMMAND_COUNT');
-            setCounter(ctx.settings, 'PIPELINE_COMMAND_COUNT', 0);
-            bumpCounter(ctx.settings, 'PIPELINE_RESULT_COUNT', queued);
-            return { status: 'ok' };
+            const queued = readCounter(ctx.settings, "PIPELINE_COMMAND_COUNT");
+            setCounter(ctx.settings, "PIPELINE_COMMAND_COUNT", 0);
+            bumpCounter(ctx.settings, "PIPELINE_RESULT_COUNT", queued);
+            return { status: "ok" };
         }
         catch (err) {
             return errResult(ctx, errorToMessage(err));
@@ -767,8 +773,8 @@ export const cmdFlushRequest = {
     },
 };
 export const cmdFlush = {
-    name: 'flush',
-    helpKey: 'flush',
+    name: "flush",
+    helpKey: "flush",
     run(ctx) {
         return cmdFlushRequest.run(ctx);
     },
@@ -777,8 +783,8 @@ export const cmdFlush = {
 // \sendpipeline — submit current buffer with stashed bind params.
 // ---------------------------------------------------------------------------
 export const cmdSendPipeline = {
-    name: 'sendpipeline',
-    helpKey: 'sendpipeline',
+    name: "sendpipeline",
+    helpKey: "sendpipeline",
     async run(ctx) {
         const ps = getPipelineState(ctx.settings);
         if (!ps) {
@@ -794,10 +800,10 @@ export const cmdSendPipeline = {
             // parameters from before the failed-outside-pipeline send.
             consumeBindState(ctx.settings);
             ctx.settings.lastErrorResult = {
-                message: '\\sendpipeline not allowed outside of pipeline mode',
+                message: "\\sendpipeline not allowed outside of pipeline mode",
             };
-            writeErr('\\sendpipeline not allowed outside of pipeline mode\n');
-            return { status: 'error', errorWritten: true };
+            writeErr("\\sendpipeline not allowed outside of pipeline mode\n");
+            return { status: "error", errorWritten: true };
         }
         const bind = consumeBindState(ctx.settings);
         // Upstream `exec_command_sendpipeline` (in pipeline mode) requires
@@ -809,10 +815,10 @@ export const cmdSendPipeline = {
         // same diagnostic, so order matters here.
         if (bind === null) {
             ctx.settings.lastErrorResult = {
-                message: '\\sendpipeline must be used after \\bind or \\bind_named',
+                message: "\\sendpipeline must be used after \\bind or \\bind_named",
             };
-            writeErr('\\sendpipeline must be used after \\bind or \\bind_named\n');
-            return { status: 'error', errorWritten: true };
+            writeErr("\\sendpipeline must be used after \\bind or \\bind_named\n");
+            return { status: "error", errorWritten: true };
         }
         const sql = ctx.queryBuf.trim();
         const stmtName = bind.name;
@@ -822,7 +828,7 @@ export const cmdSendPipeline = {
         // anonymous-`\bind` path still needs a buffer because we must
         // Parse the SQL first.
         if (!bind.byName && sql.length === 0) {
-            return errResult(ctx, 'no query buffer');
+            return errResult(ctx, "no query buffer");
         }
         try {
             // We send the full P/B/E sequence without an intervening Sync — the
@@ -832,15 +838,15 @@ export const cmdSendPipeline = {
             // an unnamed Parse so the SQL is parsed on the server in this
             // batch.
             if (!bind.byName) {
-                await ps.session.parse('', sql, []);
+                await ps.session.parse("", sql, []);
             }
             await ps.session.bind(stmtName, params);
             const exec = (async () => {
-                await ps.session.execute('', 0);
+                await ps.session.execute("", 0);
                 // PipelineSession.execute resolves with void on the public API; the
                 // session internally tracks the ResultSet and surfaces it in end().
                 return {
-                    command: '',
+                    command: "",
                     rowCount: null,
                     oid: null,
                     fields: [],
@@ -849,7 +855,7 @@ export const cmdSendPipeline = {
                 };
             })();
             ps.pending.push(exec);
-            return { status: 'reset-buf', newBuf: '' };
+            return { status: "reset-buf", newBuf: "" };
         }
         catch (err) {
             return errResult(ctx, errorToMessage(err));
@@ -860,11 +866,11 @@ export const cmdSendPipeline = {
 // \getresults [N] — drain N pending results (or all if N omitted).
 // ---------------------------------------------------------------------------
 export const cmdGetResults = {
-    name: 'getresults',
-    helpKey: 'getresults',
+    name: "getresults",
+    helpKey: "getresults",
     async run(ctx) {
         const ps = getPipelineState(ctx.settings);
-        const arg = ctx.nextArg('normal');
+        const arg = ctx.nextArg("normal");
         // Upstream `exec_command_getresults` parses the optional count BEFORE
         // checking pipeline state, so an invalid count surfaces even when
         // there's no pipeline active. The wording matches upstream verbatim
@@ -873,7 +879,7 @@ export const cmdGetResults = {
         if (arg !== null && arg.length > 0) {
             const parsed = parseInt(arg, 10);
             if (!Number.isFinite(parsed) || parsed < 0) {
-                return errResult(ctx, 'invalid number of requested results');
+                return errResult(ctx, "invalid number of requested results");
             }
             requested = parsed;
         }
@@ -883,8 +889,8 @@ export const cmdGetResults = {
         // outside of `\startpipeline / \endpipeline` brackets and right
         // after `\endpipeline`.
         if (!ps) {
-            process.stdout.write('No pending results to get\n');
-            return { status: 'ok' };
+            process.stdout.write("No pending results to get\n");
+            return { status: "ok" };
         }
         // Available items to drain = PIPELINE_SYNC_COUNT + PIPELINE_RESULT_COUNT.
         // Sync markers and data-result entries both occupy slots in libpq's
@@ -899,12 +905,12 @@ export const cmdGetResults = {
         // prints nothing on the first \getresults 1 (SyncMarker drained,
         // SYNC_COUNT: 2 → 1), the second prints nothing (SYNC_COUNT: 1 →
         // 0), and the third prints the SELECT result.
-        const syncAvailable = readCounter(ctx.settings, 'PIPELINE_SYNC_COUNT');
-        const resultAvailable = readCounter(ctx.settings, 'PIPELINE_RESULT_COUNT');
+        const syncAvailable = readCounter(ctx.settings, "PIPELINE_SYNC_COUNT");
+        const resultAvailable = readCounter(ctx.settings, "PIPELINE_RESULT_COUNT");
         const available = syncAvailable + resultAvailable;
         if (available === 0) {
-            process.stdout.write('No pending results to get\n');
-            return { status: 'ok' };
+            process.stdout.write("No pending results to get\n");
+            return { status: "ok" };
         }
         // `\getresults 0` and bare `\getresults` mean "all pending"
         // (upstream semantics).
@@ -953,12 +959,13 @@ export const cmdGetResults = {
             //      one that should surface.
             const sliceErr = (() => {
                 for (const r of settled) {
-                    if (r.status !== 'rejected')
+                    if (r.status !== "rejected")
                         continue;
                     const reason = r.reason;
-                    const isAborted = typeof reason === 'object' &&
+                    const isAborted = typeof reason === "object" &&
                         reason !== null &&
-                        reason.pipelineAborted === true;
+                        reason
+                            .pipelineAborted === true;
                     if (!isAborted)
                         return reason;
                 }
@@ -966,7 +973,7 @@ export const cmdGetResults = {
             })();
             const sessPeek = session;
             const realErr = sliceErr ??
-                (typeof sessPeek.peekRealError === 'function'
+                (typeof sessPeek.peekRealError === "function"
                     ? await sessPeek.peekRealError()
                     : null);
             // Per upstream `\getresults`: emit AT MOST ONE error / aborted
@@ -986,7 +993,7 @@ export const cmdGetResults = {
             // the remainder to RESULT_COUNT post-walk.
             for (const r of settled) {
                 walkedItems++;
-                if (r.status !== 'fulfilled') {
+                if (r.status !== "fulfilled") {
                     // Rejected promise — Parse / Bind / Execute / Close that the
                     // server responded to with ErrorResponse, or a cascaded
                     // pipelineAborted marker. Upstream `\getresults` walks
@@ -1000,10 +1007,10 @@ export const cmdGetResults = {
                     resultsDrained++;
                     if (!errorRenderedHere) {
                         const reason = r.reason;
-                        const isAborted = typeof reason === 'object' &&
+                        const isAborted = typeof reason === "object" &&
                             reason !== null &&
-                            reason.pipelineAborted ===
-                                true;
+                            reason
+                                .pipelineAborted === true;
                         if (isAborted && realErr !== null) {
                             renderPipelineError(realErr);
                         }
@@ -1033,7 +1040,7 @@ export const cmdGetResults = {
                 // attribution is fixed up at the tail of this function based
                 // on `syncAvailable`.
                 if (rs.fields.length === 0 &&
-                    rs.command === '' &&
+                    rs.command === "" &&
                     rs.rows.length === 0) {
                     syncsDrained++;
                     continue;
@@ -1044,8 +1051,8 @@ export const cmdGetResults = {
                     // `\endpipeline` (see comment there).
                     const tuplesOnly = ctx.settings.popt.topt.tuplesOnly;
                     if (!tuplesOnly) {
-                        process.stdout.write('--\n');
-                        process.stdout.write(`(${rs.rows.length} ${rs.rows.length === 1 ? 'row' : 'rows'})\n\n`);
+                        process.stdout.write("--\n");
+                        process.stdout.write(`(${rs.rows.length} ${rs.rows.length === 1 ? "row" : "rows"})\n\n`);
                     }
                 }
                 else if (rs.fields.length > 0) {
@@ -1063,7 +1070,7 @@ export const cmdGetResults = {
             // `_externalDrained` check, which is only consulted by `end()`
             // to skip ALREADY-INSPECTED rejections).
             const sessMark = session;
-            if (typeof sessMark.markDrained === 'function') {
+            if (typeof sessMark.markDrained === "function") {
                 sessMark.markDrained(end);
             }
             // Once we surface a rejection inline here, also clear any sticky
@@ -1071,7 +1078,7 @@ export const cmdGetResults = {
             // `\endpipeline`'s fallback doesn't re-emit the same diagnostic.
             if (errorRenderedHere) {
                 const sessAny = session;
-                if (typeof sessAny.clearLastError === 'function') {
+                if (typeof sessAny.clearLastError === "function") {
                     sessAny.clearLastError();
                 }
             }
@@ -1104,9 +1111,9 @@ export const cmdGetResults = {
             // `\getresults 1` x5 after 4 commands + 1 sync drains the 5th
             // call silently against the SyncMarker; a 6th call would emit
             // "No pending results to get".
-            bumpCounter(ctx.settings, 'PIPELINE_SYNC_COUNT', -syncsDrained);
-            bumpCounter(ctx.settings, 'PIPELINE_RESULT_COUNT', -resultsDrained);
-            return { status: 'ok' };
+            bumpCounter(ctx.settings, "PIPELINE_SYNC_COUNT", -syncsDrained);
+            bumpCounter(ctx.settings, "PIPELINE_RESULT_COUNT", -resultsDrained);
+            return { status: "ok" };
         }
         catch (err) {
             return errResult(ctx, errorToMessage(err));
@@ -1122,7 +1129,7 @@ export const cmdGetResults = {
 // module) continues to compile. Registration is left to `cmd_io.ts`'s
 // `registerIoCommands` so we don't double-register.
 // ---------------------------------------------------------------------------
-export { cmdGdesc } from './cmd_io.js';
+export { cmdGdesc } from "./cmd_io.js";
 // ---------------------------------------------------------------------------
 // Registration entry point.
 // ---------------------------------------------------------------------------