neon 3.1.0 → 3.1.1

package/dist/psql/command/cmd_io.js

@@ -1,1404 +1,2 @@
-import { writeErr, writeOut } from "./shared.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 { formatErrorReport, psqlErrorPrefix } from "./cmd_meta.js";
-import { captureLastError, refreshErrorVars, stripLeadingCommentsAndWS } from "../core/common.js";
-import { applyPset } from "./cmd_format.js";
-import { consumeBindState, lookupPrepared, stagedNamedBindPresent } from "./cmd_pipeline.js";
-import { closeSync, createWriteStream, fsyncSync, openSync, promises } from "node:fs";
-import * as path from "node:path";
-import { platform } from "node:os";
-import { spawn } from "node:child_process";
-//#region src/psql/command/cmd_io.ts
-/**
-* psql I/O & control backslash commands.
-*
-* TypeScript port of the following `exec_command_*` functions in upstream
-* PostgreSQL's `src/bin/psql/command.c`:
-*
-*   - `\i`,  `\include`           → exec_command_include          (normal)
-*   - `\ir`, `\include_relative`  → exec_command_include          (relative=true)
-*   - `\o`,  `\out`               → exec_command_out
-*   - `\w`,  `\write`             → exec_command_write
-*   - `\g`                        → exec_command_g
-*   - `\gx`                       → exec_command_g  (force_expanded=true)
-*   - `\gset`                     → exec_command_gset
-*   - `\gdesc`                    → exec_command_gdesc
-*   - `\gexec`                    → exec_command_gexec
-*   - `\watch`                    → exec_command_watch
-*
-* Each is exported as a `BackslashCmdSpec` and registered via
-* {@link registerIoCommands}. The single line that wires us into the
-* default dispatcher lives in `dispatch.ts::defaultRegistry()`.
-*
-* # Integration touch-points and known limitations
-*
-* Several of these commands really want to participate in the mainloop's
-* scanner/printer pipeline. This WP keeps `src/psql/core/mainloop.ts`
-* untouched, so we provide the data structures and let a follow-up WP wire
-* the consumption sites. Limitations documented per-command:
-*
-*   - `\i FILE` enqueues the file's contents on a small input queue
-*     (`./inputQueue.ts`) AND, as a stop-gap, executes the file's SQL
-*     directly via `Connection.execSimple`. Backslash commands embedded in
-*     the file are NOT processed by the scanner; the include is a "best
-*     effort: run as one big SQL blob". Once mainloop adopts the queue API
-*     this becomes a true include.
-*
-*   - `\o FILE` opens a writable stream and stashes it under a symbol on
-*     `settings`. We expose a getter (`getQueryFout`) for the mainloop to
-*     consult; until that wiring happens, query output continues to flow
-*     to the mainloop's `ctx.stdout`. The stash + close-on-rebind logic is
-*     in place and fully tested.
-*
-*   - `\g` (no arg) executes the current queryBuf directly through
-*     `Connection.execSimple` and renders via the aligned printer. This
-*     duplicates a tiny slice of mainloop's send/print pipeline, which is
-*     fine for the bytewise-simple cases this WP needs to support. For
-*     `\g FILE` / `\g |cmd` the output goes through the temporary writer.
-*
-*   - `\gx` toggles `topt.expanded` for the single execution and restores
-*     the prior value in a `try { ... } finally { ... }`.
-*
-*   - `\gset [PREFIX]` executes via `execSimple`, requires the last result
-*     to have exactly one row, and stores `${prefix}${colname}` → value
-*     for each column on `settings.vars`.
-*
-*   - `\gdesc` parses the buffered query with the extended protocol
-*     (Parse + Describe by statement, no Execute), then assembles a
-*     synthetic `Column / Type` ResultSet and renders it through the
-*     active printer (`alignedPrinter` by default; the format picker
-*     honours `\pset format`). Tuples-only mode (`\t on`) and `\o FILE`
-*     redirects ride along automatically because the same ResultSet
-*     goes through the same printer the REPL would use for a query.
-*
-*   - `\gexec` iterates the cells of the last result row-major and feeds
-*     each non-null cell back as SQL through `execSimple`. Each statement's
-*     output is rendered to stdout (or to the active queryFout stash).
-*
-*   - `\watch [INTERVAL]` re-executes the queryBuf every `INTERVAL` seconds
-*     (default 2) until SIGINT or until the iteration count limit is hit.
-*     We hook SIGINT via a transient listener that's removed on completion.
-*     Tests bypass the listener by using an AbortController exposed via
-*     `WATCH_TEST_CONTROLLER`.
-*
-* # Error format
-*
-* Upstream prints `<cmd>: <msg>` to stderr and returns failure. We mirror
-* that and also stash the message on `settings.lastErrorResult` so the
-* mainloop's `writeError()` wrapper can pick it up.
-*/
-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
-* `ctx.stdout` for query results.
-*/
-const getQueryFout = (settings) => {
-	return settings[QUERY_FOUT_KEY]?.stream ?? null;
-};
-const setQueryFout = (settings, entry) => {
-	const stash = settings;
-	if (entry === null) stash[QUERY_FOUT_KEY] = void 0;
-	else stash[QUERY_FOUT_KEY] = entry;
-};
-const closeQueryFout = async (settings) => {
-	const stash = settings;
-	const prev = stash[QUERY_FOUT_KEY];
-	if (prev) {
-		stash[QUERY_FOUT_KEY] = void 0;
-		await prev.close();
-	}
-};
-const WATCH_TEST_CONTROLLER = { ref: null };
-const errResult = (ctx, message) => {
-	ctx.settings.lastErrorResult = { message };
-	const prefix = psqlErrorPrefix(ctx.settings);
-	writeErr(`${prefix}\\${ctx.cmdName}: ${message}\n`);
-	return {
-		status: "error",
-		errorWritten: true
-	};
-};
-/**
-* Reject buffer-consuming commands when an extended pipeline is open. Upstream
-* `exec_command_g` / `gx` / `gset` / `gexec` / `watch` all guard with
-* `PQpipelineStatus(pset.db) != PQ_PIPELINE_OFF` and emit
-* `pg_log_error("\\%s not allowed in pipeline mode", cmd)` (note: no `:`
-* after the command name — different shape from `errResult`).
-*
-* `\gdesc` is the odd one out: upstream uses
-* `pg_log_error("synchronous command execution functions are not allowed in
-* pipeline mode")` because the underlying `PQdescribePrepared`/`PQfn`-style
-* helpers all share that text — the regress baseline asserts this exact
-* wording at three call sites in `psql_pipeline.out`.
-*
-* If the command proceeded it would inject a synchronous Query/Sync into the
-* queue, corrupt the pipeline state, and leave `\endpipeline` waiting forever.
-*
-* Returns `null` when not in pipeline mode (caller proceeds); otherwise
-* returns a populated error result the caller should bubble up.
-*
-* Upstream psql 18.4 leaks gate diagnostics through `pg_log_error_internal`
-* which appends to the libpq result error log on the underlying PGresult;
-* each subsequent gate hit RE-EMITS the full accumulated log plus its own
-* line ("Error messages accumulate and are repeated" — the regress comment
-* is the spec). Two `\gdesc` calls back-to-back therefore emit 3 lines
-* total: 1 for the first call, 2 for the second (one accumulated + one
-* 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 getGateErrors = (settings) => {
-	const s = settings;
-	let cur = s[PIPELINE_GATE_ERRORS_KEY];
-	if (!cur) {
-		cur = [];
-		s[PIPELINE_GATE_ERRORS_KEY] = cur;
-	}
-	return cur;
-};
-/**
-* Drop the accumulated pipeline-gate errors. Called from
-* `\endpipeline` so the next pipeline session starts fresh — without
-* this, gate errors from a closed pipeline would leak into the next
-* one.
-*/
-const clearPipelineGateErrors = (settings) => {
-	const s = settings;
-	s[PIPELINE_GATE_ERRORS_KEY] = void 0;
-};
-const pipelineGate = (ctx) => {
-	if (ctx.settings.sendMode !== "extended-pipeline") return null;
-	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);
-	if (ctx.cmdName === "gdesc") {
-		const log = getGateErrors(ctx.settings);
-		log.push(message);
-		for (const m of log) writeErr(`${prefix}${m}\n`);
-	} else writeErr(`${prefix}${message}\n`);
-	return {
-		status: "error",
-		errorWritten: true
-	};
-};
-/**
-* Set of psql variables upstream marks as "specially treated" — i.e. names
-* that have a substitute / assign hook installed in `startup.c`'s
-* `EstablishVariableSpace`. Used by `\gset` to reject assignments into
-* those names (matching upstream `StoreQueryTuple`'s `VariableHasHook`
-* check). We mirror the upstream list directly so a `\gset IGNORE` into
-* `IGNOREEOF` produces the conformance-expected warning even though our
-* settings.ts hasn't installed the IGNOREEOF / HISTFILE hooks yet — that
-* gap is tracked separately and harmless because the values are read-only
-* for us.
-*/
-const UPSTREAM_SPECIAL_VAR_NAMES = /* @__PURE__ */ 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"
-]);
-/**
-* True when `name` is a psql variable that `\gset` must skip with an
-* "attempt to \gset into specially treated variable" message. Combines the
-* registered-hook check (so future hook installations are automatically
-* covered) with the upstream-canonical list above (so cases like
-* 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);
-/**
-* Strip line and block comments from `sql` so a COPY-shaped token inside a
-* comment (e.g. dash-dash `COPY t TO STDOUT`) doesn't trigger the
-* `\g FILE` mid-batch sink. Mirrors the cheap normaliser the mainloop uses
-* before wiring `copyOutMidBatchSink`. Embedded literals are NOT stripped —
-* `'COPY x TO STDOUT'` would still match `hasCopyToStdout`, but that's the
-* same false-positive shape upstream tolerates (the regex sweep is
-* 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, "");
-/**
-* True when `sql` contains at least one `COPY ... TO STDOUT` segment.
-* Used by `runGCore` to install a CopyData sink while `\g` / `\gx` /
-* `\g FILE` / `\g |cmd` dispatches a `\;`-chained batch that mixes
-* COPY-OUT with regular SELECT statements. Without the sink the wire
-* layer drops the CopyData bytes on the floor, and the file/pipe ends
-* up with the surrounding tuple results only — see regress/psql lines
-* 5760-5787 (`COPY (SELECT 'foo') TO STDOUT \; COPY (SELECT 'bar') TO
-* STDOUT \g :g_out_file`).
-*/
-const hasCopyToStdout = (sql) => /\bCOPY\b[\s\S]*?\bTO\s+STDOUT\b/iu.test(stripSqlCommentsForCopyScan(sql));
-/**
-* Render a server-side error in upstream psql's 3-line shape (severity +
-* message, then `LINE N:` / `^` re-print) and refresh the `:LAST_ERROR_*`
-* diagnostic variables so a subsequent `\errverbose` sees the rich payload.
-*
-* Mirrors the path that `core/common.ts::writeQueryError` takes for top-level
-* statement errors: capture full ErrorResponse fields onto
-* `settings.lastErrorResult`, render via `formatErrorReport` (honouring
-* VERBOSITY + SHOW_CONTEXT), prefix only the leading severity line with
-* `psql:[<file>:<n>]:`, and update the per-statement diagnostic vars via
-* `refreshErrorVars`.
-*
-* Used by `\g`, `\gx`, `\gset`, `\gdesc`, and `\gexec` so a server-rejected
-* statement dispatched through them renders the same shape vanilla psql
-* produces, instead of the legacy `\<cmd>: <message>` one-liner.
-*/
-const formatServerError = (ctx, err, sql) => {
-	const msg = captureLastError(ctx.settings, err, sql);
-	const e = ctx.settings.lastErrorResult;
-	if (e) {
-		const lines = formatErrorReport(e, ctx.settings.verbosity, ctx.settings.showContext);
-		const prefixed = [psqlErrorPrefix(ctx.settings) + lines[0], ...lines.slice(1)];
-		writeErr(prefixed.join("\n") + "\n");
-	} else {
-		const prefix = psqlErrorPrefix(ctx.settings);
-		writeErr(`${prefix}ERROR:  ${msg}\n`);
-	}
-	refreshErrorVars(ctx.settings, { kind: "error" });
-	return {
-		status: "error",
-		errorWritten: true
-	};
-};
-/**
-* Open a writable destination for `\o` / `\w` / `\g FILE` / `\g |cmd`.
-*
-* `target` of the form `|cmd` spawns `sh -c cmd` and pipes to its stdin.
-* The returned closer waits for the child to exit and resolves to its
-* status + terminating signal (if any) so callers can render
-* `wait_result_to_str`-style errors. Any other string is treated as a
-* file path; the file is truncated.
-*/
-const openWriter = (target) => {
-	if (target.startsWith("|")) {
-		const cmd = target.slice(1);
-		const child = spawn("sh", ["-c", cmd], { stdio: [
-			"pipe",
-			"inherit",
-			"inherit"
-		] });
-		child.stdin.on("error", (err) => {
-			if (err.code !== "EPIPE") throw err;
-		});
-		return {
-			stream: child.stdin,
-			isPipe: true,
-			close: () => new Promise((resolve) => {
-				let settled = false;
-				const finish = (code, signal) => {
-					if (settled) return;
-					settled = true;
-					resolve({
-						exitCode: code,
-						signal
-					});
-				};
-				child.once("close", (code, signal) => {
-					finish(code, signal);
-				});
-				child.once("error", () => {
-					finish(127, null);
-				});
-				if (!child.stdin.destroyed) child.stdin.end();
-			})
-		};
-	}
-	const fd = openSync(target, "w");
-	const stream = createWriteStream(target, {
-		encoding: "utf8",
-		fd,
-		autoClose: false
-	});
-	let writeError = null;
-	stream.on("error", (err) => {
-		writeError = writeError ?? err;
-	});
-	return {
-		stream,
-		isPipe: false,
-		close: () => new Promise((resolve, reject) => {
-			if (writeError !== null) {
-				try {
-					closeSync(fd);
-				} catch {}
-				reject(writeError);
-				return;
-			}
-			stream.end((err) => {
-				if (err) {
-					try {
-						closeSync(fd);
-					} catch {}
-					reject(err);
-					return;
-				}
-				try {
-					fsyncSync(fd);
-				} catch {}
-				try {
-					closeSync(fd);
-				} catch (closeErr) {
-					reject(closeErr);
-					return;
-				}
-				if (platform() === "darwin") {
-					setTimeout(() => {
-						resolve({});
-					}, 25);
-					return;
-				}
-				resolve({});
-			});
-		})
-	};
-};
-/**
-* Map a Node.js errno (`err.code`) to the libc `strerror()` string
-* upstream psql renders in its `pg_log_error("%s: %m", fname)` path.
-*
-* Falls back to `err.message` (with the verbose `ENOENT: ...` prefix
-* stripped if present) so unmapped errno values still surface
-* meaningful text instead of a cryptic Node-internal phrasing.
-*/
-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";
-		default: {
-			const m = /^[A-Z]+: ([^,]+)/.exec(err.message);
-			return m ? m[1] : err.message;
-		}
-	}
-};
-/**
-* Emit a file-open failure for `\g FILE`, `\o FILE`, `\w FILE` in the
-* exact shape vanilla psql produces: a bare `<path>: <strerror>` line
-* on stderr, no `\<cmd>:` prefix (matches `pg_log_error` under terse
-* mode, which is what `psql -X` uses).
-*
-* The leading `psql:[<file>:<n>]:` tag is still applied when we're
-* reading SQL from a `\i FILE` include — `psqlErrorPrefix` returns ''
-* for stdin so the line stays bare for the interactive / harness case.
-*
-* Returns an `error` envelope with `errorWritten: true` so the mainloop
-* doesn't write a duplicate `psql: ERROR:` fallback.
-*/
-const reportFileOpenFailure = (ctx, target, err) => {
-	const line = `${target}: ${errnoToStrerror(err)}`;
-	ctx.settings.lastErrorResult = { message: line };
-	const prefix = psqlErrorPrefix(ctx.settings);
-	writeErr(`${prefix}${line}\n`);
-	return {
-		status: "error",
-		errorWritten: true
-	};
-};
-/**
-* True when `err` was thrown by our synchronous `openSync` in
-* {@link openWriter} (i.e. has an errno `code`) and the caller should
-* render it via {@link reportFileOpenFailure} rather than the generic
-* `\<cmd>: <msg>` path.
-*/
-const isFileOpenFailure = (err) => {
-	if (!err || typeof err !== "object") return false;
-	const e = err;
-	return typeof e.code === "string" && e.code.startsWith("E");
-};
-/**
-* Format a child process exit code + signal into upstream psql's
-* `wait_result_to_str` style. Mirrors the C helper in
-* `src/common/wait_error.c`:
-*
-*   - exit code 127  → `command not found`
-*   - exit code 126  → `command was not executable`
-*   - any other code → `child process exited with exit code N`
-*   - terminated by signal S → `child process was terminated by
-*     signal N: <SIG>`
-*
-* Returns null when the child exited cleanly (code 0, no signal).
-*/
-const formatChildWaitResult = (exitCode, signal) => {
-	if (signal) return `child process was terminated by signal: ${signal}`;
-	if (exitCode === null || exitCode === void 0) return null;
-	if (exitCode === 0) return null;
-	if (exitCode === 127) return "command not found";
-	if (exitCode === 126) return "command was not executable";
-	return `child process exited with exit code ${String(exitCode)}`;
-};
-/**
-* Compose the `CommandComplete`-tag line upstream prints for non-tuples-
-* producing results (DDL, DML without RETURNING, COPY). Mirrors
-* `formatCommandTag` in `core/common.ts` — duplicated to avoid the
-* cmd_io → common import cycle. Returns an empty string when no tag is
-* available (e.g. `EmptyQueryResponse` carries `command = ''`).
-*/
-const formatCommandTagText = (rs) => {
-	const command = (rs.command || "").trim();
-	if (command.length === 0) return "";
-	if (command === "INSERT") return `INSERT ${String(rs.oid ?? 0)} ${String(rs.rowCount ?? 0)}`;
-	if (rs.rowCount !== null && rs.rowCount !== void 0) return `${command} ${String(rs.rowCount)}`;
-	return command;
-};
-/**
-* Render a `ResultSet` to the supplied writable stream using the printer
-* picked from the active `\pset format`. Upstream's `do_watch`, `do_gset`,
-* `do_gexec`, and `\i` all funnel results through the standard query
-* output pipeline (`ExecQueryAndProcessResults` → `printQuery`), which
-* honours `\pset format`. Hard-coding the aligned printer here breaks the
-* conformance harness's `psql -A` runs (which expect unaligned tuples-only
-* output for things like `\watch` polled rows).
-*
-* Non-tuples-producing results (CommandComplete with `fields.length === 0`,
-* which covers DDL, DML without RETURNING, and the post-CopyDone tag for
-* `COPY ... TO STDOUT`) are rendered as a single status line instead of
-* the printer's `(0 rows)` empty-table block — matching `renderResultSets`
-* in `core/common.ts`. Tuples-only (`\t`) and quiet (`--quiet`) both
-* suppress the tag entirely.
-*/
-const renderResult = async (settings, rs, out) => {
-	if (rs.copyOutBytes && rs.copyOutBytes.length > 0) for (const chunk of rs.copyOutBytes) out.write(chunk);
-	if (rs.fields.length === 0) {
-		if (!settings.popt.topt.tuplesOnly && !settings.quiet && !rs.copyOutBytes) {
-			const tag = formatCommandTagText(rs);
-			if (tag.length > 0) out.write(`${tag}\n`);
-		}
-		return;
-	}
-	await pickActivePrinter(settings).printQuery(rs, settings.popt, out);
-};
-/**
-* Pick the printer for the active output format. Mirrors `pickPrinter`
-* in `core/common.ts` — duplicated here to avoid the cmd_io → common
-* import cycle (common.ts depends on this file for `getQueryFout`).
-*
-* `wrapped` falls back to the aligned printer (which renders `wrapped`
-* mode itself via `topt.format`).
-*/
-const pickActivePrinter = (settings) => {
-	switch (settings.popt.topt.format) {
-		case "aligned":
-		case "wrapped": return alignedPrinter;
-		case "unaligned": return unalignedPrinter;
-		case "csv": return csvPrinter;
-		case "json": return jsonPrinter;
-		case "html": return htmlPrinter;
-		case "asciidoc": return asciidocPrinter;
-		case "latex": return latexPrinter;
-		case "latex-longtable": return latexLongtablePrinter;
-		case "troff-ms": return troffMsPrinter;
-		default: return alignedPrinter;
-	}
-};
-/**
-* Pick the output target for a query result.
-*
-* Precedence: explicit `oneShot` (e.g. `\g FILE`) > the settings stash
-* (`\o FILE`) > `process.stdout`.
-*/
-const pickOut = (settings, oneShot) => {
-	if (oneShot) return oneShot;
-	return getQueryFout(settings) ?? process.stdout;
-};
-const runInclude = async (ctx, relative) => {
-	const arg = ctx.nextArg("normal");
-	if (arg === null || arg.length === 0) return errResult(ctx, "missing required argument");
-	let resolved;
-	if (path.isAbsolute(arg)) resolved = arg;
-	else if (relative && ctx.settings.inputfile) resolved = path.resolve(path.dirname(ctx.settings.inputfile), arg);
-	else resolved = path.resolve(process.cwd(), arg);
-	let contents;
-	try {
-		contents = await promises.readFile(resolved, "utf8");
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		return errResult(ctx, msg);
-	}
-	if (!ctx.settings.db) return errResult(ctx, "no connection to the server");
-	const trimmed = contents.trim();
-	if (trimmed.length === 0) return { status: "ok" };
-	const priorInputFile = ctx.settings.inputfile;
-	ctx.settings.inputfile = resolved;
-	try {
-		const results = await ctx.settings.db.execSimple(trimmed);
-		const out = pickOut(ctx.settings, null);
-		for (const rs of results) await renderResult(ctx.settings, rs, out);
-		return { status: "ok" };
-	} catch (err) {
-		const msg = err instanceof Error ? err.message : String(err);
-		return errResult(ctx, msg);
-	} finally {
-		ctx.settings.inputfile = priorInputFile;
-	}
-};
-const cmdInclude = {
-	name: "i",
-	aliases: ["include"],
-	helpKey: "i",
-	run: (ctx) => runInclude(ctx, false)
-};
-const cmdIncludeRel = {
-	name: "ir",
-	aliases: ["include_relative"],
-	helpKey: "ir",
-	run: (ctx) => runInclude(ctx, true)
-};
-const cmdOut = {
-	name: "o",
-	aliases: ["out"],
-	helpKey: "o",
-	async run(ctx) {
-		const arg = ctx.nextArg("filepipe");
-		await closeQueryFout(ctx.settings);
-		if (arg === null || arg.length === 0) return { status: "ok" };
-		try {
-			const entry = openWriter(arg);
-			setQueryFout(ctx.settings, entry);
-			return { status: "ok" };
-		} catch (err) {
-			if (!arg.startsWith("|") && isFileOpenFailure(err)) return reportFileOpenFailure(ctx, arg, err);
-			const msg = err instanceof Error ? err.message : String(err);
-			return errResult(ctx, msg);
-		}
-	}
-};
-const cmdWrite = {
-	name: "w",
-	aliases: ["write"],
-	helpKey: "w",
-	async run(ctx) {
-		const arg = ctx.nextArg("filepipe");
-		if (arg === null || arg.length === 0) return errResult(ctx, "missing required argument");
-		let entry;
-		try {
-			entry = openWriter(arg);
-		} catch (err) {
-			if (!arg.startsWith("|") && isFileOpenFailure(err)) return reportFileOpenFailure(ctx, arg, err);
-			const msg = err instanceof Error ? err.message : String(err);
-			return errResult(ctx, msg);
-		}
-		try {
-			await new Promise((resolve, reject) => {
-				entry.stream.write(ctx.queryBuf, (err) => {
-					if (err) reject(err);
-					else resolve();
-				});
-			});
-		} catch (err) {
-			const isEpipe = err instanceof Error && err.code === "EPIPE";
-			if (!entry.isPipe || !isEpipe) {
-				try {
-					await entry.close();
-				} catch {}
-				const msg = err instanceof Error ? err.message : String(err);
-				return errResult(ctx, msg);
-			}
-		}
-		try {
-			const result = await entry.close();
-			if (entry.isPipe) {
-				const msg = formatChildWaitResult(result.exitCode, result.signal);
-				if (msg !== null) {
-					const line = `${arg}: ${msg}`;
-					ctx.settings.lastErrorResult = { message: line };
-					const prefix = psqlErrorPrefix(ctx.settings);
-					writeErr(`${prefix}${line}\n`);
-					return {
-						status: "error",
-						errorWritten: true
-					};
-				}
-			}
-			return { status: "ok" };
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			return errResult(ctx, msg);
-		}
-	}
-};
-/**
-* Parse the body of a `\g (option=value option2=value2 ...)` clause —
-* the text between the outer parentheses, already stripped. Options
-* are separated by whitespace; values may be single-quoted to embed
-* spaces. Unquoted values run to the next whitespace.
-*
-* Mirrors upstream's `parse_slash_pgopts_list`. We deliberately stay
-* narrow — the conformance corpus exercises `format=`, `csv_fieldsep=`,
-* and `title=` only.
-*/
-const parseGPsetOptions = (body) => {
-	const out = [];
-	let i = 0;
-	while (i < body.length) {
-		while (i < body.length && /\s/.test(body[i])) i++;
-		if (i >= body.length) break;
-		const optStart = 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] === "=") {
-			i++;
-			if (body[i] === "'") {
-				i++;
-				while (i < body.length && body[i] !== "'") {
-					if (body[i] === "\\" && i + 1 < body.length) {
-						const next = body[i + 1];
-						if (next === "n") value += "\n";
-						else if (next === "t") value += "	";
-						else if (next === "r") value += "\r";
-						else if (next === "\\") value += "\\";
-						else if (next === "'") value += "'";
-						else value += next;
-						i += 2;
-						continue;
-					}
-					value += body[i++];
-				}
-				if (body[i] === "'") i++;
-			} else {
-				const vStart = i;
-				while (i < body.length && !/\s/.test(body[i])) i++;
-				value = body.slice(vStart, i);
-			}
-		}
-		out.push({
-			option,
-			value
-		});
-	}
-	return out;
-};
-const runGCore = async (ctx, forceExpanded) => {
-	const gated = pipelineGate(ctx);
-	if (gated !== null) return gated;
-	const trimmedBuf = stripLeadingCommentsAndWS(ctx.queryBuf);
-	const bufSql = trimmedBuf.trim();
-	let target;
-	let psetOverrides = null;
-	const rawTrimmed = ctx.rawArgs.trimStart();
-	if (rawTrimmed.startsWith("(")) {
-		const close = rawTrimmed.indexOf(")");
-		if (close === -1) return errResult(ctx, "missing right parenthesis in \\g options");
-		psetOverrides = parseGPsetOptions(rawTrimmed.slice(1, close).trim());
-		const afterParen = rawTrimmed.slice(close + 1).trim();
-		target = afterParen.length > 0 ? afterParen : null;
-	} else target = ctx.nextArg("filepipe");
-	const sql = bufSql.length > 0 ? bufSql : ctx.settings.lastQuery;
-	const hasPendingNamedBind = stagedNamedBindPresent(ctx.settings);
-	if (sql.length === 0 && !hasPendingNamedBind) return {
-		status: "reset-buf",
-		newBuf: ""
-	};
-	if (!ctx.settings.db) return errResult(ctx, "no connection to the server");
-	let oneShot = null;
-	if (target !== null && target.length > 0) try {
-		oneShot = openWriter(target);
-	} catch (err) {
-		if (!target.startsWith("|") && isFileOpenFailure(err)) return reportFileOpenFailure(ctx, target, err);
-		const msg = err instanceof Error ? err.message : String(err);
-		return errResult(ctx, msg);
-	}
-	const topt = ctx.settings.popt.topt;
-	const toptSnapshot = { ...topt };
-	if (forceExpanded) topt.expanded = "on";
-	if (psetOverrides) for (const { option, value } of psetOverrides) applyPset(topt, option, value, ctx.cmdName, true);
-	ctx.settings.lastQuery = sql;
-	const bindState = consumeBindState(ctx.settings);
-	let execError = null;
-	let copyOutSinkConn = null;
-	try {
-		const out = pickOut(ctx.settings, oneShot?.stream ?? null);
-		if (bindState?.byName) {
-			const ps = lookupPrepared(ctx.settings, bindState.name);
-			if (!ps) execError = Object.assign(/* @__PURE__ */ new Error(`prepared statement "${bindState.name}" does not exist`), {
-				severity: "ERROR",
-				code: "26000"
-			});
-			else {
-				const rs = await ps.bindAndExecute(bindState.values);
-				await renderResult(ctx.settings, rs, out);
-			}
-		} else if (bindState) {
-			const rs = await ctx.settings.db.query(sql, bindState.values);
-			await renderResult(ctx.settings, rs, out);
-		} else {
-			if (hasCopyToStdout(sql)) {
-				copyOutSinkConn = ctx.settings.db;
-				copyOutSinkConn.copyOutMidBatchSink = (chunk) => {
-					out.write(chunk);
-				};
-			}
-			const results = await ctx.settings.db.execSimple(sql);
-			for (const rs of results) await renderResult(ctx.settings, rs, out);
-		}
-	} catch (err) {
-		execError = err;
-	} finally {
-		Object.assign(topt, toptSnapshot);
-		if (copyOutSinkConn) copyOutSinkConn.copyOutMidBatchSink = null;
-	}
-	let pipeError = null;
-	if (oneShot) try {
-		await oneShot.close();
-	} catch (err) {
-		pipeError = err instanceof Error ? err.message : String(err);
-	}
-	if (execError !== null) return formatServerError(ctx, execError, bufSql.length > 0 ? trimmedBuf : sql);
-	if (pipeError !== null) return errResult(ctx, pipeError);
-	return {
-		status: "reset-buf",
-		newBuf: ""
-	};
-};
-const cmdG = {
-	name: "g",
-	helpKey: "g",
-	run: (ctx) => runGCore(ctx, false)
-};
-const cmdGx = {
-	name: "gx",
-	helpKey: "gx",
-	run: (ctx) => runGCore(ctx, true)
-};
-/**
-* `\p` / `\print` — print the query buffer the next `\g` would execute.
-*
-* Mirrors upstream `exec_command_print` in `src/bin/psql/command.c`:
-*
-*   if (query_buf && query_buf->len > 0)
-*     puts(query_buf->data);
-*   else if (previous_buf && previous_buf->len > 0)
-*     puts(previous_buf->data);
-*   else if (!pset.quiet)
-*     puts(_("Query buffer is empty."));
-*
-* Buffer-vs-previous-buffer precedence matters for the regress sequence:
-*
-*     SELECT 1;       -- executes, previous_buf := "SELECT 1;"
-*     \p              -- queryBuf empty → prints previous_buf
-*     SELECT 2 \r     -- queryBuf="SELECT 2 ", \r resets to "" without
-*                     -- touching previous_buf
-*     \p              -- queryBuf still empty → prints previous_buf
-*     SELECT 3 \p     -- queryBuf="SELECT 3 ", non-empty → prints queryBuf
-*
-* Implementation notes:
-*
-*  - We use `settings.lastQuery` as the previous-buffer source. Upstream
-*    tracks `previous_buf` independently of `pset.last_query`, but our
-*    `lastQuery` is set at the exact same point upstream sets
-*    `previous_buf` (the dispatch site in `SendQuery`-equivalent code paths
-*    in `core/common.ts` and `cmd_io.ts`'s `\g` implementation), so the
-*    semantics match for every shape exercised by the conformance corpus.
-*  - We must NOT clear queryBuf — return `status: 'ok'` so the mainloop
-*    leaves the buffer untouched. The user is inspecting, not executing.
-*  - `puts()` appends a trailing newline. We use `writeOut` and append `\n`
-*    explicitly to match.
-*/
-const cmdPrint = {
-	name: "p",
-	aliases: ["print"],
-	helpKey: "p",
-	run: (ctx) => {
-		if (ctx.queryBuf.trim().length > 0) writeOut(`${ctx.queryBuf}\n`);
-		else if (ctx.settings.lastQuery.length > 0) writeOut(`${ctx.settings.lastQuery}\n`);
-		else if (!ctx.settings.quiet) writeOut("Query buffer is empty.\n");
-		return Promise.resolve({ status: "ok" });
-	}
-};
-const formatCell = (value) => {
-	if (value === null || value === void 0) 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 String(value);
-	try {
-		return JSON.stringify(value);
-	} catch {
-		return "";
-	}
-};
-const cmdGset = {
-	name: "gset",
-	helpKey: "gset",
-	async run(ctx) {
-		const gated = pipelineGate(ctx);
-		if (gated !== null) return gated;
-		const trimmedBuf = stripLeadingCommentsAndWS(ctx.queryBuf);
-		const bufSql = trimmedBuf.trim();
-		const prefix = ctx.nextArg("normal") ?? "";
-		const sql = bufSql.length > 0 ? bufSql : ctx.settings.lastQuery.trim();
-		if (sql.length === 0) return {
-			status: "reset-buf",
-			newBuf: ""
-		};
-		if (!ctx.settings.db) return errResult(ctx, "no connection to the server");
-		ctx.settings.lastQuery = sql;
-		let results;
-		try {
-			results = await ctx.settings.db.execSimple(sql);
-		} catch (err) {
-			return formatServerError(ctx, err, bufSql.length > 0 ? trimmedBuf : sql);
-		}
-		if (results.length > 1) {
-			const out = pickOut(ctx.settings, null);
-			for (let i = 0; i < results.length - 1; i++) await renderResult(ctx.settings, results[i], out);
-		}
-		const lastRs = results[results.length - 1];
-		if (!lastRs || lastRs.fields.length === 0) return {
-			status: "reset-buf",
-			newBuf: ""
-		};
-		const rs = lastRs;
-		if (rs.rows.length === 0) {
-			ctx.settings.lastErrorResult = { message: "no rows returned for \\gset" };
-			const errPrefix = psqlErrorPrefix(ctx.settings);
-			writeErr(`${errPrefix}no rows returned for \\gset\n`);
-			return {
-				status: "error",
-				errorWritten: true
-			};
-		}
-		if (rs.rows.length > 1) {
-			ctx.settings.lastErrorResult = { 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
-			};
-		}
-		const row = rs.rows[0];
-		for (let i = 0; i < rs.fields.length; i++) {
-			const fieldName = rs.fields[i].name;
-			const name = `${prefix}${fieldName}`;
-			const cell = row[i];
-			const isNull = cell === null || cell === void 0;
-			if (isSpeciallyTreatedVar(ctx.settings, name)) {
-				const errPrefix = psqlErrorPrefix(ctx.settings);
-				writeErr(`${errPrefix}attempt to \\gset into specially treated variable "${name}" ignored\n`);
-				continue;
-			}
-			if (isNull) {
-				ctx.settings.vars.unset(name);
-				continue;
-			}
-			const value = formatCell(cell);
-			if (!ctx.settings.vars.set(name, value)) {
-				ctx.settings.lastErrorResult = { message: `invalid variable name: "${fieldName}"` };
-				const errPrefix = psqlErrorPrefix(ctx.settings);
-				writeErr(`${errPrefix}invalid variable name: "${fieldName}"\n`);
-				return {
-					status: "error",
-					errorWritten: true
-				};
-			}
-		}
-		return {
-			status: "reset-buf",
-			newBuf: ""
-		};
-	}
-};
-/**
-* Build the SQL that resolves each describe-result column's `Type` via
-* `pg_catalog.format_type(typoid, typmod)`. We feed the names + OIDs
-* + typmods through a `VALUES` literal so the server does the formatting
-* for us — the same query upstream issues from `describeFieldsByType`.
-*
-* Returns null when there are zero fields (caller emits `(0 rows)` form
-* by hand because PostgreSQL rejects an empty VALUES list).
-*/
-const buildGdescFormatQuery = (fields) => {
-	if (fields.length === 0) return null;
-	return `SELECT name AS "Column", pg_catalog.format_type(tp, tpm) AS "Type" FROM (VALUES ${fields.map((f, i) => {
-		const safeName = f.name.replace(/'/gu, "''");
-		const oid = String(f.dataTypeID >>> 0);
-		const typmod = String(f.dataTypeModifier | 0);
-		return `(${String(i)}, '${safeName}', ${oid}::oid, ${typmod}::int4)`;
-	}).join(", ")}) AS x(_idx, name, tp, tpm) ORDER BY _idx`;
-};
-/**
-* Field descriptors for the synthetic `Column / Type` ResultSet that
-* `\gdesc` emits when format_type resolution fails or yields nothing.
-*
-* We fall back to the field's raw OID so the user still sees a value.
-*/
-const GDESC_SYNTHETIC_FIELDS = [{
-	name: "Column",
-	tableID: 0,
-	columnID: 0,
-	dataTypeID: 25,
-	dataTypeSize: -1,
-	dataTypeModifier: -1,
-	format: 0
-}, {
-	name: "Type",
-	tableID: 0,
-	columnID: 0,
-	dataTypeID: 25,
-	dataTypeSize: -1,
-	dataTypeModifier: -1,
-	format: 0
-}];
-const buildSyntheticGdescResultSet = (rows) => ({
-	command: "SELECT",
-	rowCount: rows.length,
-	oid: null,
-	fields: GDESC_SYNTHETIC_FIELDS,
-	rows,
-	notices: []
-});
-const cmdGdesc = {
-	name: "gdesc",
-	helpKey: "gdesc",
-	async run(ctx) {
-		const gated = pipelineGate(ctx);
-		if (gated !== null) return gated;
-		const trimmedBuf = stripLeadingCommentsAndWS(ctx.queryBuf);
-		const sql = trimmedBuf.trim();
-		if (sql.length === 0) {
-			process.stdout.write("The command has no result, or the result has no columns.\n");
-			refreshErrorVars(ctx.settings, {
-				kind: "success",
-				rowCount: 0
-			});
-			return {
-				status: "reset-buf",
-				newBuf: ""
-			};
-		}
-		if (!ctx.settings.db) return errResult(ctx, "no connection to the server");
-		ctx.settings.lastQuery = sql;
-		let fields;
-		try {
-			const stmt = await ctx.settings.db.prepare("", sql);
-			fields = await stmt.describe();
-			try {
-				await stmt.close();
-			} catch {}
-		} catch (err) {
-			return formatServerError(ctx, err, trimmedBuf);
-		}
-		if (fields.length === 0) {
-			process.stdout.write("The command has no result, or the result has no columns.\n");
-			refreshErrorVars(ctx.settings, {
-				kind: "success",
-				rowCount: 0
-			});
-			return {
-				status: "reset-buf",
-				newBuf: ""
-			};
-		}
-		let rows;
-		const formatQuery = buildGdescFormatQuery(fields);
-		if (formatQuery === null) rows = [];
-		else {
-			const fallbackRows = () => fields.map((f) => [f.name, String(f.dataTypeID)]);
-			try {
-				const sets = await ctx.settings.db.execSimple(formatQuery);
-				const last = sets[sets.length - 1];
-				rows = last && last.rows.length > 0 ? last.rows : fallbackRows();
-			} catch {
-				rows = fallbackRows();
-			}
-		}
-		const rs = buildSyntheticGdescResultSet(rows);
-		const printer = pickActivePrinter(ctx.settings);
-		const out = pickOut(ctx.settings, null);
-		try {
-			await printer.printQuery(rs, ctx.settings.popt, out);
-		} catch (err) {
-			const msg = err instanceof Error ? err.message : String(err);
-			return errResult(ctx, msg);
-		}
-		refreshErrorVars(ctx.settings, {
-			kind: "success",
-			rowCount: rs.rowCount
-		});
-		return {
-			status: "reset-buf",
-			newBuf: ""
-		};
-	}
-};
-const cmdGexec = {
-	name: "gexec",
-	helpKey: "gexec",
-	async run(ctx) {
-		const gated = pipelineGate(ctx);
-		if (gated !== null) return gated;
-		const trimmedBuf = stripLeadingCommentsAndWS(ctx.queryBuf);
-		const bufSql = trimmedBuf.trim();
-		const sql = bufSql.length > 0 ? bufSql : ctx.settings.lastQuery.trim();
-		if (sql.length === 0) return {
-			status: "reset-buf",
-			newBuf: ""
-		};
-		if (!ctx.settings.db) return errResult(ctx, "no connection to the server");
-		ctx.settings.lastQuery = sql;
-		let firstPass;
-		try {
-			firstPass = await ctx.settings.db.execSimple(sql);
-		} catch (err) {
-			return formatServerError(ctx, err, trimmedBuf);
-		}
-		const tupled = firstPass.filter((r) => r.fields.length > 0);
-		if (tupled.length === 0) return {
-			status: "reset-buf",
-			newBuf: ""
-		};
-		const out = pickOut(ctx.settings, null);
-		const echo = ctx.settings.echo;
-		const shouldEcho = echo === "all" || echo === "queries";
-		for (const rs of tupled) for (const row of rs.rows) for (const cell of row) {
-			if (cell === null || cell === void 0) continue;
-			const statement = formatCell(cell).trim();
-			if (statement.length === 0) continue;
-			if (shouldEcho) out.write(statement + "\n");
-			try {
-				const nested = await ctx.settings.db.execSimple(statement);
-				for (const sub of nested) if (sub.fields.length > 0) await renderResult(ctx.settings, sub, out);
-			} catch (err) {
-				formatServerError(ctx, err, statement);
-				if (ctx.settings.onErrorStop) return {
-					status: "error",
-					errorWritten: true
-				};
-			}
-		}
-		return {
-			status: "reset-buf",
-			newBuf: ""
-		};
-	}
-};
-const sleepCancellable = (ms, signal) => new Promise((resolve) => {
-	const timer = setTimeout(() => {
-		signal.removeEventListener("abort", onAbort);
-		resolve();
-	}, ms);
-	const onAbort = () => {
-		clearTimeout(timer);
-		signal.removeEventListener("abort", onAbort);
-		resolve();
-	};
-	if (signal.aborted) {
-		clearTimeout(timer);
-		resolve();
-		return;
-	}
-	signal.addEventListener("abort", onAbort);
-});
-/**
-* Strictly parse a non-negative finite float.
-*
-* Returns the parsed number, or `null` for any of:
-*   - empty string
-*   - non-numeric trailing characters (e.g. `10ab`)
-*   - negative values (e.g. `-10`)
-*   - out-of-range / non-finite results (e.g. `10e400` → Infinity)
-*
-* Used to validate `\watch` intervals and the `WATCH_INTERVAL` variable.
-*/
-const parseStrictNonNegativeFloat = (raw) => {
-	if (raw.length === 0) return null;
-	if (!/^[+-]?(\d+(\.\d*)?|\.\d+)([eE][+-]?\d+)?$/.test(raw)) return null;
-	const value = parseFloat(raw);
-	if (!Number.isFinite(value)) return null;
-	if (value < 0) return null;
-	return value;
-};
-/**
-* Parse a strict non-negative integer (no exponent, no fractional).
-* Used for `c=` and `m=` / `min_rows=` argument values.
-*/
-const parseStrictNonNegativeInt = (raw) => {
-	if (raw.length === 0) return null;
-	if (!/^\d+$/.test(raw)) return null;
-	const value = parseInt(raw, 10);
-	if (!Number.isFinite(value)) return null;
-	return value;
-};
-/**
-* Default `\watch` interval (seconds). Mirrors upstream
-* `DEFAULT_WATCH_INTERVAL`. Exported so `defaultSettings` can substitute
-* it when the user unsets the `WATCH_INTERVAL` variable — upstream's
-* `watch_interval_substitute_hook` reseeds the value to `2` on null.
-*/
-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
-* 19:41:55 2026`). Upstream calls `strftime("%c", &tm)` with the C locale;
-* we reproduce the field order in vanilla English so the output matches
-* regardless of the host locale.
-*
-* Exported only for unit-testing the format ladder.
-*/
-const WEEKDAYS = [
-	"Sun",
-	"Mon",
-	"Tue",
-	"Wed",
-	"Thu",
-	"Fri",
-	"Sat"
-];
-const MONTHS = [
-	"Jan",
-	"Feb",
-	"Mar",
-	"Apr",
-	"May",
-	"Jun",
-	"Jul",
-	"Aug",
-	"Sep",
-	"Oct",
-	"Nov",
-	"Dec"
-];
-const pad2 = (n) => n < 10 ? `0${String(n)}` : String(n);
-const formatWatchTimestamp = (now) => {
-	return `${WEEKDAYS[now.getDay()]} ${MONTHS[now.getMonth()]} ${pad2(now.getDate())} ${pad2(now.getHours())}:${pad2(now.getMinutes())}:${pad2(now.getSeconds())} ${String(now.getFullYear())}`;
-};
-/**
-* Upper bound on the `WATCH_INTERVAL` variable and the positional interval
-* — matches upstream which rejects "out of range" values. Upstream uses
-* `strtod` and rejects ±Infinity; we tighten further so a single watch loop
-* cannot sleep for longer than ~100 hours, which catches obvious typos
-* without breaking legitimate slow polls.
-*/
-const WATCH_INTERVAL_MAX_SECONDS = 36e4;
-/**
-* Resolve the effective default `\watch` interval from the `WATCH_INTERVAL`
-* psql variable. Returns the parsed value, the documented default
-* (`DEFAULT_WATCH_INTERVAL`), or an `error` envelope if the variable is set
-* but parses out of range.
-*/
-const resolveWatchIntervalDefault = (settings) => {
-	const raw = settings.vars.get("WATCH_INTERVAL") ?? "2";
-	const parsed = parseStrictNonNegativeFloat(raw);
-	if (parsed === null || parsed > WATCH_INTERVAL_MAX_SECONDS) return { error: `WATCH_INTERVAL "${raw}" is out of range` };
-	return { value: parsed };
-};
-/**
-* Spawn the `\watch` pager for the full duration of the polling loop.
-*
-* Upstream `do_watch` wraps the loop in a single `popen` of
-* `PSQL_WATCH_PAGER`. It deliberately ignores `PSQL_PAGER` and `$PAGER`:
-*
-*   > we ignore the regular PSQL_PAGER or PAGER environment variables,
-*   > because traditional pagers probably won't be very useful for
-*   > showing a stream of results.
-*
-* Mirror that here. Reading from `$PAGER` would silently hijack
-* `\watch` output for any user whose shell sets `PAGER=less` (the
-* common default), which makes the loop's output disappear into a
-* subprocess that diff harnesses can't capture.
-*
-* We use a single `sh -c <pager>` spawn so the user can set the
-* variable to a full command string (`less -R`, `tee /tmp/log`, …)
-* without the caller having to tokenise it. EPIPE on the stdin pipe is
-* swallowed for the same reason as in `openWriter`: the user may quit
-* `less` while we still have writes pending in the next iteration.
-*
-* Returns `null` when `PSQL_WATCH_PAGER` is unset or whitespace-only
-* (upstream's "no pager" rule), so the caller falls back to the normal
-* output target.
-*/
-const openWatchPager = () => {
-	const cmd = process.env.PSQL_WATCH_PAGER ?? "";
-	if (cmd.trim().length === 0) return null;
-	const child = spawn("sh", ["-c", cmd], { stdio: [
-		"pipe",
-		"inherit",
-		"inherit"
-	] });
-	child.stdin.on("error", (err) => {
-		if (err.code !== "EPIPE") throw err;
-	});
-	return {
-		stream: child.stdin,
-		close: () => new Promise((resolve) => {
-			if (child.exitCode !== null || child.signalCode !== null) {
-				resolve();
-				return;
-			}
-			let settled = false;
-			const finish = () => {
-				if (settled) return;
-				settled = true;
-				resolve();
-			};
-			child.once("close", finish);
-			child.once("error", finish);
-			if (!child.stdin.destroyed) try {
-				child.stdin.end();
-			} catch (err) {
-				if (err.code !== "EPIPE") finish();
-			}
-		})
-	};
-};
-const cmdWatch = {
-	name: "watch",
-	helpKey: "watch",
-	async run(ctx) {
-		const gated = pipelineGate(ctx);
-		if (gated !== null) return gated;
-		const trimmedBuf = stripLeadingCommentsAndWS(ctx.queryBuf);
-		const sql = trimmedBuf.trim();
-		if (sql.length === 0) return errResult(ctx, "no query buffer");
-		if (!ctx.settings.db) return errResult(ctx, "no connection to the server");
-		let intervalSet = false;
-		let interval = null;
-		let iterSet = false;
-		let iterMax = 0;
-		let minRowsSet = false;
-		let minRows = 0;
-		let positionalSeen = false;
-		while (true) {
-			const arg = ctx.nextArg("normal");
-			if (arg === null) break;
-			if (arg.length === 0) continue;
-			const eqIdx = arg.indexOf("=");
-			if (eqIdx > 0) {
-				const key = arg.slice(0, eqIdx);
-				const value = arg.slice(eqIdx + 1);
-				if (key === "i") {
-					if (intervalSet) return errResult(ctx, "interval value is specified more than once");
-					const parsed = parseStrictNonNegativeFloat(value);
-					if (parsed === null || parsed > WATCH_INTERVAL_MAX_SECONDS) return errResult(ctx, `incorrect interval value "${value}"`);
-					interval = parsed;
-					intervalSet = true;
-					continue;
-				}
-				if (key === "c") {
-					if (iterSet) return errResult(ctx, "iteration count is specified more than once");
-					const parsed = parseStrictNonNegativeInt(value);
-					if (parsed === null || parsed === 0) return errResult(ctx, `incorrect iteration count "${value}"`);
-					iterMax = parsed;
-					iterSet = true;
-					continue;
-				}
-				if (key === "m" || key === "min_rows") {
-					if (minRowsSet) return errResult(ctx, "minimum row count specified more than once");
-					const parsed = parseStrictNonNegativeInt(value);
-					if (parsed === null) return errResult(ctx, `incorrect minimum row count "${value}"`);
-					minRows = parsed;
-					minRowsSet = true;
-					continue;
-				}
-				return errResult(ctx, `unrecognized option "${key}"`);
-			}
-			if (positionalSeen || intervalSet) return errResult(ctx, "interval value is specified more than once");
-			const parsed = parseStrictNonNegativeFloat(arg);
-			if (parsed === null || parsed > WATCH_INTERVAL_MAX_SECONDS) return errResult(ctx, `incorrect interval value "${arg}"`);
-			interval = parsed;
-			intervalSet = true;
-			positionalSeen = true;
-		}
-		if (interval === null) {
-			const resolved = resolveWatchIntervalDefault(ctx.settings);
-			if ("error" in resolved) return errResult(ctx, resolved.error);
-			interval = resolved.value;
-		}
-		const intervalMs = Math.round(interval * 1e3);
-		const controller = WATCH_TEST_CONTROLLER.ref ?? new AbortController();
-		const sigintHandler = () => {
-			controller.abort();
-		};
-		const installedSigint = WATCH_TEST_CONTROLLER.ref === null;
-		if (installedSigint) process.once("SIGINT", sigintHandler);
-		const pager = openWatchPager();
-		const out = pager?.stream ?? pickOut(ctx.settings, null);
-		try {
-			let iter = 0;
-			while (!controller.signal.aborted) {
-				iter++;
-				const stamp = formatWatchTimestamp(/* @__PURE__ */ new Date());
-				out.write(`${stamp} (every ${String(interval)}s)\n\n`);
-				let lastRowCount = 0;
-				try {
-					const results = await ctx.settings.db.execSimple(sql);
-					for (const rs of results) if (rs.fields.length > 0) {
-						await renderResult(ctx.settings, rs, out);
-						lastRowCount = rs.rows.length;
-					}
-				} catch (err) {
-					return formatServerError(ctx, err, trimmedBuf);
-				}
-				if (iterSet && iter >= iterMax) break;
-				if (minRowsSet && lastRowCount < minRows) break;
-				if (controller.signal.aborted) break;
-				if (intervalMs > 0) await sleepCancellable(intervalMs, controller.signal);
-			}
-			if (!pager) out.write("\n");
-			return {
-				status: "reset-buf",
-				newBuf: ""
-			};
-		} finally {
-			if (installedSigint) process.removeListener("SIGINT", sigintHandler);
-			if (pager) await pager.close();
-		}
-	}
-};
-const registerIoCommands = (registry) => {
-	registry.register(cmdInclude);
-	registry.register(cmdIncludeRel);
-	registry.register(cmdOut);
-	registry.register(cmdWrite);
-	registry.register(cmdG);
-	registry.register(cmdGx);
-	registry.register(cmdPrint);
-	registry.register(cmdGset);
-	registry.register(cmdGdesc);
-	registry.register(cmdGexec);
-	registry.register(cmdWatch);
-};
-//#endregion
+import { A as cmdPrint, C as cmdGdesc, D as cmdInclude, E as cmdGx, F as registerIoCommands, M as cmdWrite, N as formatWatchTimestamp, O as cmdIncludeRel, P as getQueryFout, S as cmdG, T as cmdGset, b as WATCH_TEST_CONTROLLER, j as cmdWatch, k as cmdOut, w as cmdGexec, x as clearPipelineGateErrors, y as DEFAULT_WATCH_INTERVAL } from "../../_chunks/cmd_pipeline-CUbBO9U_.js";
 export { DEFAULT_WATCH_INTERVAL, WATCH_TEST_CONTROLLER, clearPipelineGateErrors, cmdG, cmdGdesc, cmdGexec, cmdGset, cmdGx, cmdInclude, cmdIncludeRel, cmdOut, cmdPrint, cmdWatch, cmdWrite, formatWatchTimestamp, getQueryFout, registerIoCommands };