@mason-data/cli 0.0.0-stage → 0.6.2

package/dist/src/duck/rewrite.js

@@ -0,0 +1,4001 @@
+import { pathIndex, SESSION_VARIABLE } from "./functions.js";
+import { cellsOf as cellsOfProgram, numericLiteral } from "../lib/pg-numeric.js";
+import { caseTwins } from "./pgtree.js";
+import { canonicalRead, readKey } from "./kept-route.js";
+import { atTimeZoneOf } from "../lib/timezone.js";
+/** Whether pg_database's collation is a libc locale's (not C or POSIX), whose order is read from the database
+ *  (src/duck/libc-order.ts) for `duckCollation`'s `libc` */
+export const isLibcCollation = (provider, collate) => provider !== "b" && provider !== "i" && !/^(C|POSIX)([.].*)?$/i.test(collate);
+/** The source's collation as DuckDB follows it, from pg_database: `provider` c (libc), i (ICU) or b (builtin). */
+export function duckCollation(provider, collate, locale, known) {
+    const icuName = (l) => {
+        const lang = l.replace(/[.@].*$/, "").replace(/-/g, "_").toLowerCase();
+        if (known.has(lang))
+            return lang;
+        const base = lang.split("_")[0];
+        return known.has(base) ? base : null;
+    };
+    if (provider === "b")
+        return { kind: "bytes" };
+    if (/^(C|POSIX)([.].*)?$/i.test(collate) && provider !== "i")
+        return { kind: "bytes", ascii: true };
+    if (provider === "i") {
+        const name = icuName(locale ?? collate);
+        if (name === null)
+            throw new Error(`the source database's ICU locale ${JSON.stringify(locale ?? collate)} has no DuckDB collation: Mason cannot sort text as it does`);
+        return { kind: "icu", name };
+    }
+    const name = icuName(collate);
+    if (name === null)
+        throw new Error(`the source database's collation ${JSON.stringify(collate)} has no DuckDB collation to follow: Mason cannot sort text as it does`);
+    return { kind: "libc", icu: name };
+}
+export class Unrewritable extends Error {
+    hint;
+    gap;
+    constructor(message, hint, gap) { super(message); this.hint = hint; this.gap = gap; }
+}
+// --------------------------------------------------------------------------------------------------------- the types
+const INT2 = 21, INT4 = 23, INT8 = 20, FLOAT4 = 700, FLOAT8 = 701, NUMERIC = 1700, TEXT = 25, VARCHAR = 1043, BPCHAR = 1042, NAME = 19;
+const DATE = 1082, TIMESTAMP = 1114, TIMESTAMPTZ = 1184, INTERVAL = 1186, JSON_OID = 114, JSONB = 3802, UNKNOWN = 705, INET = 869, RECORD = 2249;
+const INTEGERS = new Set([INT2, INT4, INT8]);
+const FLOATS = new Set([FLOAT4, FLOAT8]);
+/** the fields of a time that grow with it, ±Infinity of an infinite one (Postgres 14+); the rest are NULL of it */
+const MONOTONIC = new Set(["year", "years", "decade", "decades", "century", "centuries", "millennium", "millennia", "isoyear", "epoch", "julian"]);
+/** an interval field's numeric scale: a second's is 6, a millisecond's 3, an epoch's 6 */
+const INTERVAL_SCALE = { second: "6", seconds: "6", millisecond: "3", milliseconds: "3", epoch: "6" };
+const NUMBER_TYPES = new Set([INT2, INT4, INT8, FLOAT4, FLOAT8, NUMERIC]);
+/** an array type's element (the numbers', where an IN list's element type decides a comparison) */
+const NUMBER_ELEMENT = { 1005: INT2, 1007: INT4, 1016: INT8, 1021: FLOAT4, 1022: FLOAT8, 1231: NUMERIC };
+const TEXTS = new Set([TEXT, VARCHAR, BPCHAR, NAME, UNKNOWN]);
+const JSONS = new Set([JSON_OID, JSONB]);
+const BOOL = 16, UUID = 2950, TIME = 1083, BYTEA = 17;
+/** pg_type's array types of the element types above */
+const ARRAYS = new Set([1000, 1001, 1005, 1007, 1009, 1014, 1015, 1016, 1021, 1022, 1028, 1115, 1182, 1183, 1185, 1187, 1231, 2951, 199, 3807]);
+/** pg_collation's C and POSIX: byte order */
+const BYTE_COLLATIONS = new Set([950, 951]);
+/** The DuckDB type a Postgres type is cast to (a typmod's numeric(p, s) included), or null where DuckDB has none. */
+function duckTypeOf(oid, typmod = -1) {
+    switch (oid) {
+        case INT2: return ["smallint"];
+        case INT4: return ["integer"];
+        case INT8: return ["bigint"];
+        case FLOAT4: return ["real"];
+        case FLOAT8: return ["double"];
+        case NUMERIC: {
+            if (typmod < 4)
+                return null;
+            const p = ((typmod - 4) >> 16) & 0xffff, s = (typmod - 4) & 0xffff;
+            return p <= 38 ? ["decimal", String(p), String(s)] : ["double"];
+        }
+        case TEXT:
+        case VARCHAR:
+        case BPCHAR:
+        case NAME:
+        case UNKNOWN: return ["varchar"];
+        case 16: return ["boolean"];
+        case DATE: return ["date"];
+        case TIMESTAMP: return ["timestamp"];
+        case TIMESTAMPTZ: return ["timestamptz"];
+        case INTERVAL: return ["interval"];
+        case 1083: return ["time"];
+        case 2950: return ["uuid"];
+        case JSON_OID:
+        case JSONB: return ["json"];
+        case 17: return ["blob"];
+        default: return null;
+    }
+}
+// ---------------------------------------------------------------------------------------------------- tree builders
+const S = (s) => ({ String: { sval: s } });
+const strConst = (s) => ({ A_Const: { sval: { sval: s } } });
+const intConst = (n) => ({ A_Const: { ival: n === 0 ? {} : { ival: n } } });
+const numConst = (text) => ({ A_Const: { fval: { fval: text } } });
+const nullConst = () => ({ A_Const: { isnull: true } });
+const boolConst = (v) => ({ A_Const: { boolval: v ? { boolval: true } : {} } });
+const arrayOf = (elements) => ({ A_ArrayExpr: { elements } });
+const or = (args) => ({ BoolExpr: { boolop: "OR_EXPR", args } });
+const isNotNull = (n) => ({ NullTest: { arg: n, nulltesttype: "IS_NOT_NULL" } });
+// a Mason function's first argument is the session (src/duck/functions.ts "every call carries its session"): DuckDB
+// folds `getvariable` to the session's literal at bind time
+const fn = (name, args, extra = {}) => ({
+    FuncCall: { funcname: [S(name)], args: name.startsWith("__mason_") ? [fn("getvariable", [strConst(SESSION_VARIABLE)]), ...args] : args, funcformat: "COERCE_EXPLICIT_CALL", ...extra },
+});
+const cast = (arg, type) => ({
+    TypeCast: { arg, typeName: { names: [S(type[0])], ...(type.length > 1 ? { typmods: type.slice(1).map((t) => intConst(Number(t))) } : {}), typemod: -1 } },
+});
+/** a value as DuckDB's ENUM of these labels (`CAST(x AS enum('sad', 'ok'))`), or a list of it */
+const enumCast = (arg, labels, list = false) => ({ TypeCast: { arg, typeName: { names: [S("enum")], typmods: labels.map(strConst), typemod: -1,
+            ...(list ? { arrayBounds: [{ Integer: { ival: -1 } }] } : {}) } } });
+const arrayCast = (arg, element) => ({ TypeCast: { arg, typeName: { names: [S(element)], typemod: -1, arrayBounds: [{ Integer: { ival: -1 } }] } } });
+const op = (name, l, r) => ({ A_Expr: { kind: "AEXPR_OP", name: [S(name)], ...(l === null ? {} : { lexpr: l }), rexpr: r } });
+const not = (n) => ({ BoolExpr: { boolop: "NOT_EXPR", args: [n] } });
+const and = (args) => ({ BoolExpr: { boolop: "AND_EXPR", args } });
+const caseWhen = (arms, otherwise) => ({
+    CaseExpr: { args: arms.map(([expr, result]) => ({ CaseWhen: { expr, result } })), ...(otherwise === null ? {} : { defresult: otherwise }) },
+});
+const isNull = (n) => ({ NullTest: { arg: n, nulltesttype: "IS_NULL" } });
+const collate = (n, name) => ({ CollateClause: { arg: n, collname: [S(name)] } });
+const row = (args) => ({ RowExpr: { args, row_format: "COERCE_EXPLICIT_CALL" } });
+const concat = (...parts) => parts.reduce((a, b) => op("||", a, b));
+const kindOf = (n) => Object.keys(n)[0];
+const bodyOf = (n) => n[kindOf(n)];
+const isNode = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && Object.keys(v).length === 1 && /^[A-Z]/.test(Object.keys(v)[0]);
+const names = (list) => Array.isArray(list) ? list.map((x) => isNode(x) && kindOf(x) === "String" ? String(bodyOf(x).sval ?? "") : "") : [];
+/** a function's or type's name without its `pg_catalog.` */
+const lastName = (list) => { const n = names(list); return (n[n.length - 1] ?? "").toLowerCase(); };
+const constString = (n) => n !== undefined && kindOf(n) === "A_Const" && bodyOf(n).sval !== undefined ? String(bodyOf(n).sval.sval ?? "") : null;
+const constInt = (n) => {
+    if (n === undefined || kindOf(n) !== "A_Const")
+        return null;
+    const b = bodyOf(n);
+    return b.ival !== undefined ? Number(b.ival.ival ?? 0) : null;
+};
+// ---------------------------------------------------------------------------------------------------- the rewrite
+/** what a raw node kind is analysed into (pgtree.ts's node names), to find ITS entry among those at one offset */
+const ANALYSED = {
+    ColumnRef: ["VAR"],
+    A_Const: ["CONST"],
+    ParamRef: ["PARAM"],
+    FuncCall: ["FUNCEXPR", "AGGREF", "WINDOWFUNC", "COERCEVIAIO", "RELABELTYPE", "ARRAYCOERCEEXPR", "OPEXPR", "MINMAXEXPR", "SQLVALUEFUNCTION"],
+    A_Expr: ["OPEXPR", "DISTINCTEXPR", "NULLIFEXPR", "SCALARARRAYOPEXPR", "BOOLEXPR", "FUNCEXPR"],
+    TypeCast: ["FUNCEXPR", "COERCEVIAIO", "RELABELTYPE", "CONST", "ARRAYCOERCEEXPR", "COERCETODOMAIN"],
+    CaseExpr: ["CASEEXPR"], CoalesceExpr: ["COALESCEEXPR"], MinMaxExpr: ["MINMAXEXPR"], SubLink: ["SUBLINK"], NullTest: ["NULLTEST"],
+    BoolExpr: ["BOOLEXPR"], A_ArrayExpr: ["ARRAYEXPR"], RowExpr: ["ROWEXPR"], SQLValueFunction: ["SQLVALUEFUNCTION"],
+    A_Indirection: ["SUBSCRIPTINGREF", "FIELDSELECT", "FUNCEXPR"], CollateClause: ["COLLATEEXPR"], BooleanTest: ["BOOLEANTEST"],
+};
+/**
+ * A NODE THE REWRITE PLACED TWICE (the walker's detector, Rewriter.walk): the walker runs a node's rule at its first
+ * place only, so a node a rule put in two places is rewritten in one — the json read's column was qualified in the
+ * first arm of its CASE alone (42804 from DuckDB; a review finding). Each is a bug of the rule that placed it:
+ * it should clone the node per use. Recorded here, never refused (the second place may well need no rule), and held to
+ * none by the tests that answer statements (tests/duck-wire.test.ts, tests/duck-corpus.test.ts, the oracle).
+ */
+const PLACED_TWICE = [];
+function placedTwice(kind, b) {
+    if (PLACED_TWICE.length < 100)
+        PLACED_TWICE.push(`a ${kind} at offset ${typeof b.location === "number" ? b.location : "?"}: ${JSON.stringify(b).slice(0, 160)}`);
+}
+/** the nodes the rewrite placed twice since the process began (at most 100): none, when every rule clones per use */
+export const nodesPlacedTwice = () => PLACED_TWICE;
+class Rewriter {
+    types;
+    base;
+    collation;
+    params;
+    /** bodies whose rule has run: a rule may wrap its own node, which must not be rewritten twice */
+    done = new WeakSet();
+    /** the statement's own bodies (and copies of them): only these are rewritten, never a node a rule built */
+    original = new WeakSet();
+    /** the statement's own bodies the walk has met, each in its one place (walk) */
+    placed = new WeakSet();
+    /** the bodies whose own rule's answer is being walked: met there, a body is in the place its rule put it */
+    answering = new Set();
+    /** the function calls a FROM reads (a set-returning function there is a table, not unnest's) */
+    inFrom = new WeakSet();
+    /** how the database changes a letter's case */
+    caseMode;
+    /** the ANY / ALL comparisons already guarded against a NULL array (the guard holds the comparison, walked again) */
+    nullArrayTested = new WeakSet();
+    /** the catalog's enums: each one's labels in their declared order, and its array type's element */
+    enums;
+    /** the catalog's user types by OID (`citext`), for the few the rewrite knows (src/duck/plan.ts reads pg_type) */
+    userTypes;
+    /** a copied table's row type: its columns, by the catalog's OID (src/duck/plan.ts) */
+    rowTypes;
+    /** the session's TimeZone the statement was analysed under (a relative literal's day is its) */
+    timeZone;
+    /** the stored JSON paths (src/duck/kept-route.ts): null where none is consulted (the feature off, a test) */
+    kept;
+    /** every read of a copied table's JSON column by literal steps the statement makes, stored or not: the request log's
+     *  `json_reads`, which the keeper's policy reads (src/duck/kept.ts `review`) */
+    jsonReads = new Map();
+    constructor(analysis, base, collation, userTypes = new Map(), rowTypes = new Map(), timeZone = "UTC", enums = { labels: new Map(), arrays: new Map() }, kept = null) {
+        this.types = analysis.types;
+        this.base = base;
+        this.collation = collation;
+        this.params = analysis.params;
+        this.userTypes = userTypes;
+        this.rowTypes = rowTypes;
+        this.timeZone = timeZone;
+        this.enums = enums;
+        this.kept = kept;
+        this.caseMode = collation.kind === "icu" ? "icu" : collation.kind === "bytes" && collation.ascii === true ? "ascii" : "libc";
+        this.twins = caseTwins(analysis.tree);
+    }
+    /** the subqueries and CTEs whose columns have twins in another case, by the name the query calls them (caseTwins) */
+    twins;
+    /**
+     * A STORED JSON PATH READ FROM ITS COLUMN (docs/DESIGN.md "Stored JSON paths"): `l` a copied table's
+     * json or jsonb column (Typed.relation) read by literal `steps` — recorded as one of the statement's reads (as its
+     * one path: canonicalRead), and, when every row of its path is stored (READY, src/duck/kept.ts), answered from the
+     * hidden column ALONE: the read names no document, so DuckDB reads only the stored column (on the test server a
+     * whole-table read through a CASE whose fallback named the document still read every document: 41.6 s, where a small
+     * column's scan took 8.5 s). The column holds the path's `->` answer (the value's JSON text) or `KEPT_NULL` (a NULL
+     * answer), so `->` is the column with the mark read as NULL, and `->>` is derived from it (`keptText`). Only a path
+     * whose column is not EXACT — a row unset, or marked to be computed (src/duck/functions.ts keptJsonValue) — keeps
+     * the document: `CASE WHEN <col> IS NULL OR <col> = KEPT_RECOMPUTE THEN <the call> ELSE <from the column> END`.
+     * null: not such a read, or not stored — the caller writes the call.
+     */
+    keptRead(l, steps, either, canonical, asText) {
+        if (this.kept === null || kindOf(l) !== "ColumnRef")
+            return null;
+        const path = constString(steps);
+        const fields = (bodyOf(l).fields ?? []);
+        const last = fields.at(-1);
+        const t = this.typed(l);
+        if (path === null || last === undefined || kindOf(last) !== "String" || t === null || t.node !== "VAR" || t.relation === undefined || t.renamed !== null)
+            return null;
+        const at = this.kept.at(t.relation.relid, t.relation.attno);
+        if (at === null)
+            return null;
+        const read = canonicalRead({ source: at.source, column: at.column, steps: path, either, canonical, asText });
+        this.jsonReads.set(readKey(read), read);
+        const ready = this.kept.ready(read);
+        if (ready === null)
+            return null;
+        // the column as the statement names it (its FROM item's alias or table, as rule() qualifies a bare one)
+        const prefix = fields.length === 1 && t.qualifier !== null ? [S(t.qualifier)] : fields.slice(0, -1).map((f) => structuredClone(f));
+        const column = () => ({ ColumnRef: { fields: [...prefix.map((f) => structuredClone(f)), S(ready.name)] } });
+        const nul = () => fn("chr", [intConst(0)]);
+        const value = asText ? keptText(column, canonical) : caseWhen([[op("=", column(), nul()), nullConst()]], column());
+        if (ready.exact)
+            return value;
+        // (a copied table's column, checked above: a jsonb's text is the copy's canonical one)
+        return caseWhen([[or([isNull(column()), op("=", column(), op("||", nul(), strConst("!")))]), jsonGet(this.cp, l, steps, either, canonical, asText, canonical)]], value);
+    }
+    /**
+     * A JSON READ OFF `base` BY `steps`: from its stored column where every row holds it (keptRead), else DuckDB's own
+     * read where that is Postgres's answer, else the function (jsonGet). A jsonb's text holds each key once only where it
+     * is a COPIED TABLE'S column (the copy holds Postgres's canonical text; Typed.relation, as the stored paths find a
+     * column's table): a jsonb the statement computes — jsonb_object_agg, jsonb_build_object, in a CTE, a subquery or an
+     * arm of a UNION — is written by the rewrite as text that may hold a key twice, whose `->>` in Postgres is the LAST
+     * value, so its read checks every object on the way as a json column's does (a review finding).
+     */
+    jsonRead(base, steps, either, canonical, asText) {
+        const t = kindOf(base) === "ColumnRef" ? this.typed(base) : null;
+        const copied = t !== null && t.node === "VAR" && t.relation !== undefined;
+        return this.keptRead(base, steps, either, canonical, asText) ?? jsonGet(this.cp, base, steps, either, canonical, asText, canonical && copied);
+    }
+    isCitext(oid) { return oid !== null && this.userTypes.get(oid) === "citext"; }
+    /** a text lower-cased by the database's case rules (what Postgres's citext compares, sorts and groups: str_tolower
+     *  under the default collation) */
+    lowerOf(n) {
+        return this.caseMode === "libc" ? fn("lower", [n]) : fn("__mason_case", [n, boolConst(false), strConst(this.caseMode)]);
+    }
+    /** a citext value as the text citext compares: lower-cased, typed as text under the database's collation, so the
+     *  text rules (the collation's sort keys, LIKE's escape) apply to it */
+    foldCitext(n) {
+        const out = this.lowerOf(n);
+        this.synthetic.set(bodyOf(out), { node: "FUNCEXPR", type: TEXT, typmod: -1, args: [], oid: null, format: null, collation: 100, inputCollation: 100, levelsUp: null, datum: null, qualifier: null, renamed: null });
+        return out;
+    }
+    /** the nodes the rewrite made whose type it decided itself (a citext lower-cased to text) */
+    synthetic = new WeakMap();
+    /** every CTE the statement declares, by name, from the queries walked so far (a subquery may read an outer one's) */
+    ctes = new Map();
+    /** What Postgres made of this raw node: its entry at the node's offset, of a kind the raw kind is analysed into. */
+    typed(n) {
+        const own = this.typedAt(n);
+        if (own !== null)
+            return own;
+        // an ORDER BY or a window's ORDER BY that repeats an expression of the SELECT list is analysed as THAT target
+        // (findTargetlistEntrySQL99): its own offset is in no analysed node, the same expression's elsewhere is
+        return this.byShape.get(shapeOf(n)) ?? null;
+    }
+    /** the nodes the rewrite made that Postgres analysed as another: typed as that one */
+    typedLike = new WeakMap();
+    /** what `widen` made, and the type it made it: a rule after it reads that type (a date widened to a timestamptz is
+     *  one, never cast again), and a second pass leaves it as it is — a SELECT's expression and its GROUP BY twin must
+     *  print alike, or DuckDB refuses the grouping (42803) */
+    widened = new WeakMap();
+    /** a literal Postgres analysed only where the statement repeats it (src/duck/rewrite.ts `typeCast`) */
+    constLike = new WeakMap();
+    /** the analysed type of each expression's shape (its tree less offsets), from the first place it was analysed */
+    byShape = new Map();
+    /** after `adopt`: every expression of the statement whose offset Postgres analysed, by its shape */
+    indexShapes(v) {
+        if (Array.isArray(v)) {
+            for (const x of v)
+                this.indexShapes(x);
+            return;
+        }
+        if (v === null || typeof v !== "object")
+            return;
+        if (isNode(v)) {
+            const t = this.typedAt(v);
+            if (t !== null) {
+                const k = shapeOf(v);
+                if (!this.byShape.has(k))
+                    this.byShape.set(k, t);
+            }
+        }
+        for (const x of Object.values(isNode(v) ? bodyOf(v) : v))
+            this.indexShapes(x);
+    }
+    typedAt(n) {
+        const k = kindOf(n);
+        const b = bodyOf(n);
+        const own = this.synthetic.get(b);
+        if (own !== undefined)
+            return own;
+        if (k === "TypeCast") {
+            // a cast to the type the value already has leaves no node of its own: the value's
+            return this.at(b, ANALYSED.TypeCast) ?? (b.arg !== undefined ? this.typedAt(b.arg) : null);
+        }
+        if (k === "CollateClause")
+            return b.arg !== undefined ? this.typedAt(b.arg) : null;
+        // a node the rewrite made that reads as another (decidedByKey's any_value, a set operation's sort column)
+        const like = this.typedLike.get(b);
+        if (like !== undefined)
+            return this.typed(like);
+        const kinds = ANALYSED[k];
+        return kinds === undefined ? null : this.at(b, kinds);
+    }
+    at(b, kinds) {
+        if (typeof b.location !== "number" || b.location < 0)
+            return null;
+        return this.types.get(b.location - this.base)?.find((t) => kinds.includes(t.node)) ?? null;
+    }
+    typeOf(n) { return this.widened.get(bodyOf(n)) ?? this.typed(n)?.type ?? null; }
+    // ------------------------------------------------------------------------------------------------ the walk
+    /** marks every body of the statement as its own */
+    adopt(v) {
+        if (Array.isArray(v)) {
+            for (const x of v)
+                this.adopt(x);
+            return;
+        }
+        if (v === null || typeof v !== "object")
+            return;
+        if (isNode(v))
+            this.original.add(bodyOf(v));
+        for (const [k, x] of Object.entries(isNode(v) ? bodyOf(v) : v))
+            this.adopt(armOf(k, x) ?? x);
+    }
+    /** `clone` for the helpers outside the class */
+    cp = (n) => this.clone(n);
+    /** a deep copy that stays the statement's own (a rule that uses a node twice rewrites each use) */
+    clone(v) {
+        if (Array.isArray(v))
+            return v.map((x) => this.clone(x));
+        if (v === null || typeof v !== "object")
+            return v;
+        const out = {};
+        for (const [k, x] of Object.entries(v))
+            out[k] = this.clone(x);
+        if (isNode(v) && this.original.has(bodyOf(v)))
+            this.original.add(bodyOf(out));
+        // a node the rewrite typed itself stays typed (a picked operand of min / max, exactOf)
+        const own = isNode(v) ? this.synthetic.get(bodyOf(v)) : undefined;
+        if (own !== undefined)
+            this.synthetic.set(bodyOf(out), own);
+        return out;
+    }
+    walk(v) {
+        if (Array.isArray(v)) {
+            const out = [];
+            for (const x of v) {
+                const w = this.walk(x);
+                // a rule may answer several nodes for one (a sort key is several under a libc collation)
+                if (Array.isArray(w) && isNode(x))
+                    out.push(...w);
+                else
+                    out.push(w);
+            }
+            return out;
+        }
+        if (v === null || typeof v !== "object")
+            return v;
+        if (isNode(v)) {
+            const k = kindOf(v);
+            const b = bodyOf(v);
+            if (this.original.has(b)) {
+                // ONE PLACE PER NODE: a body met again, outside its own rule's answer, is a node a rule placed twice — and the
+                // second place would skip its rule (qualified or renamed in its first place alone; a review finding).
+                // A rule that uses a node twice clones it per use (`clone`, `cp`)
+                if (this.placed.has(b) && !this.answering.has(b))
+                    placedTwice(k, b);
+                this.placed.add(b);
+            }
+            if (this.original.has(b) && !this.done.has(b)) {
+                this.done.add(b);
+                const r = this.rule(k, b);
+                if (r !== null) {
+                    // the answer may hold the node itself (a rule wrapping its own node): that is the same place
+                    this.answering.add(b);
+                    try {
+                        return Array.isArray(r) ? r.map((x) => this.walk(x)) : this.walk(r);
+                    }
+                    finally {
+                        this.answering.delete(b);
+                    }
+                }
+            }
+            return { [k]: this.walkBody(b) };
+        }
+        return this.walkBody(v);
+    }
+    walkBody(b) {
+        const out = {};
+        for (const [key, x] of Object.entries(b)) {
+            const arm = armOf(key, x);
+            if (arm === null) {
+                out[key] = this.walk(x);
+                continue;
+            }
+            // a set operation's arm is a query of its own: every rule of a SELECT (its GROUP BY's decided columns, its ORDER
+            // BY's collation, its WITH TIES) applies to it, as to the statement
+            const w = this.walk(arm);
+            if (!isNode(w) || kindOf(w) !== "SelectStmt")
+                throw new Unrewritable("this arm of a set operation is not supported by Mason", "write the arm as a subquery: SELECT * FROM (…) AS a", "unverified");
+            out[key] = bodyOf(w);
+        }
+        return out;
+    }
+    /** a node's rewrite, or null to keep it (its children are still walked) */
+    rule(k, b) {
+        switch (k) {
+            case "SelectStmt": return this.select(b);
+            case "A_Expr": return this.aExpr(b);
+            case "FuncCall": {
+                const r = this.funcCall(b);
+                if (r === null && b.agg_within_group === true)
+                    this.widenArgs(b);
+                return r;
+            }
+            case "TypeCast": return this.typeCast(b);
+            case "A_Const": return this.aConst(b);
+            case "ParamRef": return this.param(b);
+            case "SortBy": return this.sortBy(b, null, null);
+            case "RangeFunction": return this.rangeFunction(b);
+            case "CollateClause": return this.collateClause(b);
+            case "MinMaxExpr": return this.minMax(b);
+            case "SQLValueFunction": return this.sqlValueFunction(b);
+            // a row as a value anywhere but the SELECT list, a cast to text and the json functions (rowValues) is a struct
+            // to DuckDB, compared, tested and grouped by its rules
+            case "ColumnRef":
+            case "RowExpr": {
+                const t = this.typed({ [k]: b });
+                if (t !== null && (k === "RowExpr" ? t.node === "ROWEXPR" : t.node === "VAR" && this.isRowType(t.type))) {
+                    throw new Unrewritable("a row used as a value here (compared, tested, grouped or sorted) is not supported by Mason", "compare, test or sort its columns", "row-value");
+                }
+                // a bare name another FROM item has in another case (`"Email"` beside `email`) is ambiguous to DuckDB, which
+                // binds names case-insensitively: it is qualified with the FROM item Postgres resolved it to
+                // and a column its subquery has twice in two cases (`"T"`, `t`) is that subquery's renamed one (caseTwins)
+                const fields = (b.fields ?? []);
+                const last = fields.at(-1);
+                if (k === "ColumnRef" && t?.node === "VAR" && last !== undefined && kindOf(last) === "String" && (t.renamed !== null || (t.qualifier !== null && fields.length === 1))) {
+                    const prefix = fields.length === 1 && t.qualifier !== null ? [S(t.qualifier)] : fields.slice(0, -1);
+                    return { ColumnRef: { ...b, fields: [...prefix, t.renamed !== null ? S(t.renamed) : last] } };
+                }
+                return null;
+            }
+            case "RangeSubselect":
+            case "RangeVar": {
+                // a subquery or a CTE whose columns have twins in another case: named by an alias list, the twins renamed
+                const alias = b.alias;
+                const name = alias?.aliasname ?? (k === "RangeVar" ? b.relname : undefined);
+                const names = typeof name === "string" && alias?.colnames === undefined ? this.twins.get(name) : undefined;
+                if (names !== undefined)
+                    b.alias = { ...(alias ?? {}), aliasname: name, colnames: names.map(S) };
+                return null;
+            }
+            default: return null;
+        }
+    }
+    /**
+     * A ZONE AS POSTGRES READS IT (AT TIME ZONE, date_trunc's third argument): an IANA name in any case, spelled as tzdata
+     * spells it; `UT` and `Z` as UTC. Postgres reads an abbreviation or a POSIX zone with a fixed offset (`CST` is -06 all
+     * year, `UTC+3` three hours west) where DuckDB reads several as another zone (`CST` as Chicago's, `IST` as India's,
+     * `UTC+3` east), so those are refused (src/lib/timezone.ts atTimeZoneOf, the rule the other paths apply): a constant
+     * here, a row's value when it is read (`__mason_zone`).
+     */
+    zoneArg(z) {
+        const text = constString(z);
+        if (text === null)
+            return fn("__mason_zone", [z]);
+        const read = atTimeZoneOf(text);
+        if ("problem" in read)
+            throw new Unrewritable(read.problem, "write an IANA zone name (America/Chicago, Asia/Kolkata)", read.sqlstate === "0A000" ? "zone-abbreviation" : { postgres: read.sqlstate });
+        return strConst(read.zone);
+    }
+    /** the parameters the session sends the transaction's start in (DuckPlan.clock), numbered after the statement's own */
+    clock = {};
+    /** the transaction's start as of the Parse (`parse`) or the execution (`exec`), a TIMESTAMPTZ parameter */
+    now(which) {
+        this.clock[which] ??= this.params.length + Object.keys(this.clock).length + 1;
+        return cast({ ParamRef: { number: this.clock[which] } }, ["timestamptz"]);
+    }
+    /**
+     * A RELATIVE TIME LITERAL (`'now'`, `'today'`, `'tomorrow'`, `'yesterday'`): Postgres reads it once, when it analyses
+     * the statement — the transaction's start, and its day in the session's zone — and a prepared statement keeps that
+     * value. So it is the Parse's start (a parameter the session sends), never DuckDB's clock or the plan's.
+     */
+    relativeTime(word, type) {
+        const days = { now: 0, today: 0, tomorrow: 1, yesterday: -1 }[word];
+        const zone = strConst(this.timeZone);
+        const local = fn("timezone", [zone, this.now("parse")]);
+        const day = () => { const d = cast(fn("timezone", [strConst(this.timeZone), this.now("parse")]), ["date"]); return days === 0 ? d : op("+", d, intConst(days)); };
+        if (type === DATE)
+            return day();
+        if (type === TIMESTAMP)
+            return word === "now" ? local : cast(day(), ["timestamp"]);
+        return word === "now" ? this.now("parse") : fn("timezone", [zone, cast(day(), ["timestamp"])]);
+    }
+    /** CURRENT_DATE and its kin: the transaction's start as of the execution, in the session's zone (DuckDB's own clock
+     *  starts with each statement, and a transaction of several would read several) */
+    sqlValueFunction(b) {
+        const exec = () => this.now("exec");
+        switch (b.op) {
+            case "SVFOP_CURRENT_TIMESTAMP": return exec();
+            case "SVFOP_CURRENT_DATE": return cast(exec(), ["date"]);
+            case "SVFOP_LOCALTIMESTAMP": return cast(exec(), ["timestamp"]);
+            case "SVFOP_LOCALTIME": return cast(cast(exec(), ["timestamp"]), ["time"]);
+            default: return null;
+        }
+    }
+    isRowType(oid) { return oid === RECORD || this.userTypes.get(oid)?.startsWith("rowtype:") === true; }
+    /** a typed reference to a FROM item's column (a row's, read as its columns) */
+    typedRef(names, type, typmod) {
+        const n = { ColumnRef: { fields: names.map(S) } };
+        this.synthetic.set(bodyOf(n), { node: "VAR", type, typmod, args: [], oid: null, format: null, collation: TEXTS.has(type) ? 100 : 0, inputCollation: 0, levelsUp: 0, datum: null, qualifier: null, renamed: null });
+        return n;
+    }
+    /** a whole row's columns as values, each typed: a FROM item's (`r`, `r.*`, a table's own name) or a ROW(…)'s; null
+     *  where n is no row */
+    rowFields(n, select) {
+        const k = kindOf(n);
+        if (k === "RowExpr") {
+            if (this.typed(n)?.node !== "ROWEXPR")
+                return null;
+            return (bodyOf(n).args ?? []).map((a, i) => ({ name: `f${i + 1}`, value: a, type: this.typeOf(a) }));
+        }
+        if (k !== "ColumnRef")
+            return null;
+        const fields = (bodyOf(n).fields ?? []);
+        const star = fields.length === 2 && kindOf(fields[1]) === "A_Star";
+        if (fields.length !== 1 && !star)
+            return null;
+        const t = this.typed(n);
+        if (t === null || t.node !== "VAR" || !this.isRowType(t.type))
+            return null;
+        const alias = String(bodyOf(fields[0]).sval);
+        const table = this.rowTypes.get(t.type);
+        if (table !== undefined)
+            return table.map((c) => ({ name: c.name, value: this.typedRef([alias, c.name], c.type, c.typmod), type: c.type }));
+        if (t.type !== RECORD)
+            throw new Unrewritable(`a row of ${this.userTypes.get(t.type)?.replace(/^rowtype:/, "") ?? "a table"} is not supported by Mason: Mason copied the table in part`, "name its columns instead", "row-value");
+        const source = this.fromSources(select).filter((q) => q.alias === alias);
+        if (source.length !== 1)
+            throw new Unrewritable("a row of this FROM item is not supported by Mason", "name its columns instead", "row-value");
+        let q = bodyOf(source[0].query);
+        while (q.op !== undefined && q.op !== "SETOP_NONE" && q.larg !== undefined)
+            q = q.larg;
+        const targets = (q.targetList ?? []);
+        if (targets.some((x) => hasStar(bodyOf(x).val)))
+            throw new Unrewritable("a row of a subquery that selects * is not supported by Mason", "name the subquery's columns", "row-value");
+        return targets.map((x) => {
+            const val = bodyOf(x).val;
+            const name = bodyOf(x).name ?? figureColname(val);
+            const typed = this.typed(val);
+            return { name, value: this.typedRef([alias, name], typed?.type ?? TEXT, typed?.typmod ?? -1), type: typed?.type ?? null };
+        });
+    }
+    /** a row's text as record_out writes it: each column's text, quoted where it must be, NULL as nothing */
+    recordText(cols) {
+        for (const c of cols)
+            if (c.type !== null && this.isRowType(c.type))
+                throw new Unrewritable("a row holding a row is not supported by Mason", "name the inner row's columns", "row-value");
+        return fn("__mason_record_text", cols.map((c) => this.pgText(c.value, c.type, false) ?? cast(c.value, ["varchar"])));
+    }
+    /** a row's json as row_to_json writes it (`{"id":1,"t":"a"}`) */
+    rowJson(cols, fnName) {
+        const values = cols.map((c) => this.jsonValue(c.value, c.type, fnName));
+        return fn("__mason_json_build", [strConst(`r:${values.map((v) => `s${v.kind}`).join("")}`), ...cols.flatMap((c, i) => [strConst(c.name), values[i].value])]);
+    }
+    /**
+     * A ROW AS A VALUE (the corpus run: `SELECT r FROM (…) r`, `row_to_json(t)`, `json_agg(t)`): DuckDB holds
+     * it as a struct, written `{'id': 1}`. In this query's own expressions (not its subqueries'), each row the SELECT list
+     * writes, casts to text or hands a json function is written as Postgres writes it, from its columns; any other row is
+     * refused by the ColumnRef / RowExpr rule.
+     */
+    rowValues(b) {
+        const textTypes = new Set(["text", "varchar"]);
+        const visit = (v, inList) => {
+            if (Array.isArray(v))
+                return v.map((x) => visit(x, inList));
+            if (!isNode(v))
+                return v;
+            const k = kindOf(v), body = bodyOf(v);
+            if (k === "SelectStmt" || k === "SubLink" || k === "RangeSubselect")
+                return v;
+            if (inList) {
+                const cols = this.rowFields(v, b);
+                if (cols !== null)
+                    return this.recordText(cols);
+            }
+            if (k === "TypeCast" && isNode(body.arg) && textTypes.has(lastName(body.typeName?.names))) {
+                const cols = this.rowFields(body.arg, b);
+                if (cols !== null)
+                    return this.recordText(cols);
+            }
+            if (k === "FuncCall" && Array.isArray(body.args) && body.args.length >= 1 && body.over === undefined) {
+                const name = lastName(body.funcname);
+                const cols = ["to_json", "to_jsonb", "row_to_json", "json_agg", "jsonb_agg"].includes(name) ? this.rowFields(body.args[0], b) : null;
+                if (cols !== null) {
+                    if (body.args.length > 1)
+                        throw new Unrewritable(`${name}() of a row with more arguments is not supported by Mason`, `${name}(row)`, "row-value");
+                    const json = this.rowJson(cols, name);
+                    if (name === "to_json" || name === "row_to_json")
+                        return json;
+                    if (name === "to_jsonb")
+                        return cast(fn("__mason_jsonb_text", [json]), ["json"]);
+                    if (body.agg_distinct === true)
+                        throw new Unrewritable(`${name}(DISTINCT …) is not supported by Mason`, `select the DISTINCT values in a subquery and ${name} them`, "json-agg-distinct");
+                    // json_agg puts a line break before each row but the first (json_agg_transfn: a composite's or an array's)
+                    const array = linedAgg(body, concat(strConst("\n "), json), this.done);
+                    return name === "jsonb_agg" ? cast(fn("__mason_jsonb_text", [array]), ["json"]) : array;
+                }
+            }
+            const out = {};
+            for (const [key, x] of Object.entries(body))
+                out[key] = visit(x, false);
+            // the node stays the statement's own (its rule still runs), with its children replaced in place
+            for (const [key, x] of Object.entries(out))
+                body[key] = x;
+            return v;
+        };
+        if (Array.isArray(b.targetList))
+            for (const t of b.targetList) {
+                const tb = bodyOf(t);
+                if (isNode(tb.val))
+                    tb.val = visit(tb.val, true);
+            }
+        for (const key of ["whereClause", "havingClause"])
+            if (isNode(b[key]))
+                b[key] = visit(b[key], false);
+    }
+    // ---------------------------------------------------------------------------------------- SELECT
+    select(b) {
+        for (const c of (b.withClause?.ctes ?? []))
+            if (isNode(c) && typeof bodyOf(c).ctename === "string" && isNode(bodyOf(c).ctequery))
+                this.ctes.set(bodyOf(c).ctename, bodyOf(c).ctequery);
+        this.rowValues(b);
+        // a GROUP BY of an output name is grouped by its ordinal: DuckDB binds a name without regard to case, so `"Name"`
+        // would be another table's `name` (the corpus run of fbbf8f08), where Postgres finds no input column of that name
+        if (Array.isArray(b.groupClause) && Array.isArray(b.targetList)) {
+            const targets = b.targetList;
+            b.groupClause = b.groupClause.map((g) => {
+                const f = kindOf(g) === "ColumnRef" ? names(bodyOf(g).fields) : [];
+                if (f.length !== 1 || this.typedAt(g)?.node === "VAR")
+                    return g;
+                const at = targets.findIndex((t) => bodyOf(t).name === f[0]);
+                return at >= 0 && targets.filter((t) => bodyOf(t).name === f[0]).length === 1 ? intConst(at + 1) : g;
+            });
+        }
+        for (const g of (b.groupClause ?? []))
+            if (isNode(g) && kindOf(g) !== "GroupingSet")
+                this.comparable(this.groupedExpression(g, b), "GROUP BY");
+        if (Array.isArray(b.distinctClause))
+            for (const t of (b.targetList ?? []))
+                if (isNode(bodyOf(t).val))
+                    this.comparable(bodyOf(t).val, "SELECT DISTINCT");
+        if (b.op !== undefined && b.op !== "SETOP_NONE" && b.all !== true) {
+            let first = b;
+            while (first.larg !== undefined)
+                first = first.larg;
+            for (const t of (first.targetList ?? []))
+                if (isNode(bodyOf(t).val))
+                    this.comparable(bodyOf(t).val, `${String(b.op).replace("SETOP_", "")} (without ALL) of`);
+        }
+        this.decidedByKey(b);
+        // the statement's own ORDER BY: an ordinal or an output name sorts by that target's expression, so its key is
+        // built over the expression (DuckDB's `ORDER BY 1 COLLATE …` would sort by the constant)
+        if (Array.isArray(b.sortClause) && Array.isArray(b.targetList) && (b.op === undefined || b.op === "SETOP_NONE")) {
+            const targets = b.targetList;
+            b.sortClause = b.sortClause.flatMap((s) => {
+                const sb = bodyOf(s);
+                this.done.add(sb);
+                return this.sortBy(sb, targets, b) ?? [s];
+            });
+        }
+        if (Array.isArray(b.sortClause) && b.op !== undefined && b.op !== "SETOP_NONE")
+            this.setOperationOrdinals(b);
+        if (b.limitOption === "LIMIT_OPTION_WITH_TIES")
+            return this.withTies(b);
+        return null;
+    }
+    /**
+     * A SET OPERATION'S ORDER BY of a text column (`… UNION … ORDER BY 1`, or `ORDER BY status` where the first SELECT
+     * says `o.status`): Postgres sorts by its output column, which it analysed at no offset of the ORDER BY's own, so the
+     * SortBy rule found no type and DuckDB sorted by bytes. Each is typed as the first SELECT's target, and an ordinal is
+     * sorted by that output column's name, so the rule builds the collation's keys. A target with no name of its own is
+     * given one: Postgres's analysis names the columns the tool reads, never DuckDB's.
+     */
+    setOperationOrdinals(b) {
+        // a set operation's arms are SelectStmt bodies, unwrapped (libpg-query's larg / rarg)
+        let arm = b;
+        while (arm.op !== undefined && arm.op !== "SETOP_NONE" && arm.larg !== undefined)
+            arm = isNode(arm.larg) ? bodyOf(arm.larg) : arm.larg;
+        const targets = (arm.targetList ?? []);
+        const outputName = (t) => typeof t.name === "string" ? t.name
+            : isNode(t.val) && kindOf(t.val) === "ColumnRef" ? names(bodyOf(t.val).fields).at(-1) ?? null : null;
+        for (const s of b.sortClause) {
+            const sb = bodyOf(s);
+            const by = sb.node;
+            const f = kindOf(by) === "ColumnRef" ? names(bodyOf(by).fields) : [];
+            if (f.length === 1) {
+                const named = targets.map(bodyOf).filter((t) => outputName(t) === f[0]);
+                if (named.length === 1)
+                    this.typedLike.set(bodyOf(by), named[0].val);
+                continue;
+            }
+            const n = constInt(by);
+            if (n === null || n < 1 || n > targets.length)
+                continue;
+            if (targets.slice(0, n).some((t) => hasStar(bodyOf(t).val))) {
+                throw new Unrewritable("ORDER BY a column number of a set operation whose first SELECT lists * is not supported by Mason", "ORDER BY the column's name", "setop-ordinal-star");
+            }
+            const target = bodyOf(targets[n - 1]);
+            const value = target.val;
+            const c = this.textCollation(value);
+            if (c === null || c.kind === "bytes")
+                continue;
+            if (target.name === undefined)
+                target.name = `__mason_sort_${n}`;
+            const ref = { ColumnRef: { fields: [S(String(target.name))] } };
+            this.typedLike.set(bodyOf(ref), value);
+            sb.node = ref;
+        }
+    }
+    /**
+     * A COLUMN THE GROUP'S KEY DECIDES (`SELECT c.id, c.name … GROUP BY c.id`, c.id the primary key): Postgres accepts it
+     * ungrouped (functional dependency), DuckDB refuses it (42803). Postgres accepted this statement, so every column of
+     * this query outside an aggregate has one value per group: `any_value(column)` is that value, exactly — in the SELECT
+     * list, HAVING, ORDER BY, a window's OVER, and a correlated subquery (where this query's column is one level up:
+     * DuckDB, as SQL says, computes an aggregate of outer columns in the outer query). `t.*` is `any_value(COLUMNS(t.*))`.
+     * A group key itself is left as it is, and so are an aggregate's argument, a subquery's own columns, and a grouping
+     * set (where a key reads NULL in its total rows).
+     */
+    decidedByKey(b) {
+        const groups = (b.groupClause ?? []);
+        if (groups.length === 0 || groups.some((g) => kindOf(g) === "GroupingSet"))
+            return;
+        const targets = (b.targetList ?? []);
+        // a target the GROUP BY names by its ordinal or its output name is a key itself, and DuckDB reads it there: untouched
+        const keyTargets = new Set();
+        for (const g of groups) {
+            const n = constInt(g);
+            if (n !== null && n >= 1 && n <= targets.length) {
+                keyTargets.add(n - 1);
+                continue;
+            }
+            // a bare name is an output name only where it is no input column (Postgres prefers the column)
+            const f = kindOf(g) === "ColumnRef" ? names(bodyOf(g).fields) : [];
+            if (f.length === 1 && this.typedAt(g)?.node !== "VAR")
+                targets.forEach((t, i) => { if (bodyOf(t).name === f[0])
+                    keyTargets.add(i); });
+        }
+        const grouped = new Set([...groups.map(shapeOf), ...[...keyTargets].map((i) => shapeOf(bodyOf(targets[i]).val))]);
+        // `depth`: the subqueries between here and this query (a correlated subquery's column of this query is levelsUp 1)
+        const wrap = (v, depth) => {
+            if (Array.isArray(v))
+                return v.map((x) => wrap(x, depth));
+            if (v === null || typeof v !== "object")
+                return v;
+            // a plain body (a window's OVER, a SubLink's select): its parts
+            if (!isNode(v)) {
+                for (const [key, x] of Object.entries(v))
+                    if (key !== "location")
+                        v[key] = wrap(x, depth);
+                return v;
+            }
+            const k = kindOf(v), n = bodyOf(v);
+            if (grouped.has(shapeOf(v)))
+                return v;
+            if (k === "SubLink") {
+                for (const [key, x] of Object.entries(n))
+                    if (key !== "location")
+                        n[key] = wrap(x, depth + 1);
+                return v;
+            }
+            if (k === "FuncCall" && n.over === undefined && this.typed(v)?.node === "AGGREF")
+                return v;
+            if (k === "ColumnRef" && hasStar(v)) {
+                if (depth > 0)
+                    return v;
+                // `c.*` beside an aggregate: every column of c, each through any_value (DuckDB's COLUMNS expands the star)
+                const call = { FuncCall: { funcname: [S("any_value")], args: [{ FuncCall: { funcname: [S("columns")], args: [v], funcformat: "COERCE_EXPLICIT_CALL" } }], funcformat: "COERCE_EXPLICIT_CALL" } };
+                this.done.add(bodyOf(call));
+                return call;
+            }
+            if (k === "ColumnRef") {
+                // an output name (`ORDER BY p` of `max(x) AS p`) is the target, no column: its shape may be another query's
+                // column (the corpus run of fbbf8f08: `… GROUP BY p` outside read it as one, and any_value(p) nested aggregates)
+                const f = names(n.fields);
+                if (depth === 0 && f.length === 1 && this.typedAt(v) === null && targets.some((t) => bodyOf(t).name === f[0]))
+                    return v;
+                const t = this.typed(v);
+                if (t?.node !== "VAR" || t.levelsUp !== depth)
+                    return v;
+                const call = { FuncCall: { funcname: [S("any_value")], args: [v], funcformat: "COERCE_EXPLICIT_CALL" } };
+                this.done.add(bodyOf(call));
+                // typed as the column it reads: a sort's collation, a cast's source type
+                this.typedLike.set(bodyOf(call), v);
+                return call;
+            }
+            for (const [key, x] of Object.entries(n))
+                if (key !== "location")
+                    n[key] = wrap(x, depth);
+            return v;
+        };
+        targets.forEach((t, i) => { if (!keyTargets.has(i)) {
+            const tb = bodyOf(t);
+            tb.val = wrap(tb.val, 0);
+        } });
+        if (b.havingClause !== undefined)
+            b.havingClause = wrap(b.havingClause, 0);
+        if (Array.isArray(b.sortClause))
+            for (const s of b.sortClause) {
+                const sb = bodyOf(s);
+                sb.node = wrap(sb.node, 0);
+            }
+    }
+    /**
+     * `FETCH FIRST n ROWS WITH TIES` (DuckDB has none): the rows whose rank under the ORDER BY is at most n — the
+     * statement, with that rank as a column of its own, read by a statement around it that keeps those rows in the
+     * same order and leaves the rank out (`* EXCLUDE`, DuckDB's).
+     */
+    withTies(b) {
+        if (b.distinctClause !== undefined)
+            throw new Unrewritable("FETCH … WITH TIES over a SELECT DISTINCT is not supported by Mason (DuckDB has no WITH TIES)", "select the DISTINCT rows in a subquery and FETCH … WITH TIES from it", "with-ties-distinct");
+        const order = b.sortClause ?? [];
+        const count = b.limitCount;
+        delete b.limitCount;
+        b.limitOption = "LIMIT_OPTION_DEFAULT";
+        const offset = b.limitOffset;
+        delete b.limitOffset;
+        const rankName = "__mason_rank";
+        const sortCopy = order.map((o) => this.clone(o));
+        for (const s of sortCopy)
+            this.done.add(bodyOf(s));
+        const rank = { FuncCall: { funcname: [S("rank")], over: { orderClause: sortCopy, frameOptions: 1058 }, funcformat: "COERCE_EXPLICIT_CALL" } };
+        this.done.add(bodyOf(rank));
+        b.targetList = [...b.targetList, { ResTarget: { name: rankName, val: rank } }];
+        const inner = { SelectStmt: b };
+        // the rank of the first row past the offset is offset + 1; a row is kept while its rank is within offset + n
+        const bound = offset === undefined ? count : op("+", offset, count);
+        const outer = {
+            targetList: [{ ResTarget: { val: { ColumnRef: { fields: [{ A_Star: {} }] } } } }],
+            fromClause: [{ RangeSubselect: { subquery: inner, alias: { aliasname: "__mason_ties" } } }],
+            whereClause: op("<=", { ColumnRef: { fields: [S(rankName)] } }, bound),
+            sortClause: [{ SortBy: { node: { ColumnRef: { fields: [S(rankName)] } }, sortby_dir: "SORTBY_DEFAULT", sortby_nulls: "SORTBY_NULLS_DEFAULT" } }],
+            op: "SETOP_NONE",
+        };
+        if (offset !== undefined)
+            outer.limitOffset = offset;
+        this.done.add(outer);
+        this.excludeRank = true;
+        return { SelectStmt: outer };
+    }
+    /** the outer WITH TIES statement reads `*` and must not send its rank: the server drops that last column */
+    excludeRank = false;
+    // ------------------------------------------------------------------------------------- exact numerics
+    /** The statement's numeric result columns as programs, their cells appended to its SELECT list (before the walk,
+     *  which rewrites each cell as it rewrites the column). Only a plain SELECT: a UNION or a DISTINCT would read the
+     *  hidden cells as part of each row. */
+    exactColumns(stmt, fields) {
+        if (kindOf(stmt) !== "SelectStmt" || fields === null)
+            return [];
+        const b = bodyOf(stmt);
+        if ((b.op !== undefined && b.op !== "SETOP_NONE") || b.distinctClause !== undefined || b.limitOption === "LIMIT_OPTION_WITH_TIES")
+            return [];
+        const targets = (b.targetList ?? []);
+        if (targets.length !== fields.length || targets.some((t) => hasStar(bodyOf(t).val)))
+            return [];
+        const grouped = (Array.isArray(b.groupClause) && b.groupClause.length > 0) || b.havingClause !== undefined || targets.some((t) => this.hasAggregate(bodyOf(t).val));
+        const groupShapes = new Set((b.groupClause ?? []).map((g) => {
+            const n = constInt(g);
+            return shapeOf(n !== null && n >= 1 && n <= targets.length ? bodyOf(targets[n - 1]).val : g);
+        }));
+        const cells = [];
+        const out = [];
+        targets.forEach((target, i) => {
+            const field = fields[i];
+            let node = bodyOf(target).val;
+            let text = false;
+            // a numeric's text (a varchar(n) cuts it, which the program does not: left to the rewrite's cast)
+            if (TEXTS.has(field.oid) && (field.typmod ?? -1) < 0 && kindOf(node) === "TypeCast" && this.typeOf(bodyOf(node).arg) === NUMERIC) {
+                node = bodyOf(node).arg;
+                text = true;
+            }
+            else if (field.oid !== NUMERIC)
+                return;
+            const mine = [];
+            const cell = (n, conv = "exact") => {
+                if (grouped && !this.validGrouped(n, groupShapes))
+                    throw NOT_EXACT;
+                const shape = `${conv}:${shapeOf(n)}`;
+                let at = mine.findIndex((c) => c.shape === shape);
+                if (at < 0) {
+                    mine.push({ node: n, conv, shape });
+                    at = mine.length - 1;
+                }
+                return { op: "cell", key: String(at) };
+            };
+            let built;
+            try {
+                built = this.exactOf(node, cell);
+            }
+            catch (e) {
+                if (e === NOT_EXACT)
+                    return;
+                throw e;
+            }
+            if (built === null || !worthComputing(built.p) && mine.every((c) => c.conv === "exact"))
+                return;
+            // a numeric(p, s) column as it is: the wire pads it to s (src/duck/types.ts pgTypedColumn), no program needed
+            if (built.p.op === "pad" && built.p.arg.op === "cell" && !text && (field.typmod ?? -1) >= 4 && ((field.typmod - 4) & 0xffff) === built.p.scale)
+                return;
+            // the column's cells after every earlier column's
+            const base = cells.length;
+            cells.push(...mine);
+            out.push({ column: i, program: offsetCells(built.p, base), cells: [], text });
+        });
+        if (out.length === 0)
+            return [];
+        for (const c of out)
+            c.cells = cells.map((x) => x.conv);
+        b.targetList = [...targets, ...cells.map((c, j) => ({ ResTarget: { name: `__mason_cell_${j}`, val: this.clone(c.node) } }))];
+        return out;
+    }
+    /**
+     * The exact columns of a statement whose outermost query PASSES THROUGH what an inner one computed: `SELECT * FROM
+     * (inner) s`, a CTE read whole, the columns of one subquery by name (Metabase's nested question), a UNION ALL whose
+     * every arm builds the same programs. The inner query selects its cells (`exactColumns`), the outer selects them
+     * after its own columns, and the programs are the inner's at the outer's column. Anything else that computes over an
+     * inner exact numeric reads DuckDB's value (docs/SQL-SUPPORT.md `nested-exact-numeric`).
+     */
+    exactThrough(stmt, fields) {
+        if (fields === null || kindOf(stmt) !== "SelectStmt")
+            return [];
+        // the query's CTEs are visible to every query inside it (`WITH base AS (…) SELECT b.x FROM (SELECT * FROM base) b`)
+        const ctes = bodyOf(stmt).withClause?.recursive === true ? [] : (bodyOf(stmt).withClause?.ctes ?? []);
+        this.cteScope.push(ctes);
+        try {
+            return this.exactThroughIn(stmt, fields);
+        }
+        finally {
+            this.cteScope.pop();
+        }
+    }
+    /** the CTEs of the queries `exactThrough` is inside, outermost first (a recursive WITH's are none: never read whole) */
+    cteScope = [];
+    exactThroughIn(stmt, fields) {
+        const b = bodyOf(stmt);
+        if (b.op === "SETOP_UNION" && b.all === true)
+            return this.exactArms(b, fields);
+        const direct = this.exactColumns(stmt, fields);
+        if (direct.length > 0)
+            return direct;
+        const through = this.passThrough(b);
+        if (through === null)
+            return [];
+        const inner = this.exactThrough(through.query, this.outputFields(through.query));
+        if (inner.length === 0)
+            return [];
+        const cells = inner[0].cells.length;
+        if (through.columns !== "star") {
+            const targets = (b.targetList ?? []);
+            b.targetList = [...targets, ...Array.from({ length: cells }, (_, j) => ({ ResTarget: { name: `__mason_cell_${j}`,
+                        val: { ColumnRef: { fields: [S(through.alias), S(`__mason_cell_${j}`)] } } } }))];
+        }
+        const map = through.columns;
+        return inner.flatMap((e) => (map === "star" ? [e.column] : map.flatMap((k, i) => k === e.column ? [i] : []))
+            .filter((i) => i < fields.length && fields[i].oid === NUMERIC || e.text).map((column) => ({ ...e, column })));
+    }
+    /** a UNION ALL's arms, each with the same programs at the same columns (else none is computed) */
+    exactArms(b, fields) {
+        const arms = [];
+        const flatten = (n) => {
+            const x = bodyOf(n);
+            if (x.op === "SETOP_UNION" && x.all === true && x.larg !== undefined && x.rarg !== undefined) {
+                flatten({ SelectStmt: x.larg });
+                flatten({ SelectStmt: x.rarg });
+            }
+            else
+                arms.push(n);
+        };
+        flatten({ SelectStmt: b });
+        // an arm typed otherwise than the union (an integer arm of a numeric column) is cast by Postgres: not this program
+        if (arms.some((a) => { const f = this.outputFields(a); return f === null || f.some((x, i) => x.oid !== fields[i]?.oid); }))
+            return [];
+        const trial = arms.map((a) => this.exactThrough(this.clone(a), fields));
+        const first = JSON.stringify(trial[0]);
+        if (trial[0].length === 0 || trial.some((t) => JSON.stringify(t) !== first))
+            return [];
+        const made = arms.map((a) => this.exactThrough(a, fields));
+        return made[0];
+    }
+    /** an outer query that only reads one subquery's or CTE's columns: the inner query, its alias, and which inner
+     *  column each outer one is ("star": all of them, in order) */
+    passThrough(b) {
+        if ((b.op !== undefined && b.op !== "SETOP_NONE") || b.groupClause !== undefined || b.havingClause !== undefined || b.distinctClause !== undefined || b.windowClause !== undefined)
+            return null;
+        const from = (b.fromClause ?? []);
+        if (from.length !== 1)
+            return null;
+        const f = from[0];
+        let query, alias;
+        if (kindOf(f) === "RangeSubselect") {
+            query = bodyOf(f).subquery;
+            alias = bodyOf(f).alias?.aliasname;
+        }
+        else if (kindOf(f) === "RangeVar" && bodyOf(f).schemaname === undefined) {
+            // its own WITH first, then the enclosing queries', innermost first (a nearer CTE of the name shadows a farther)
+            if (b.withClause?.recursive === true)
+                return null;
+            const scopes = [(b.withClause?.ctes ?? []), ...[...this.cteScope].reverse()];
+            const cte = scopes.map((list) => list.find((c) => bodyOf(c).ctename === bodyOf(f).relname)).find((c) => c !== undefined);
+            if (cte === undefined || bodyOf(cte).aliascolnames !== undefined)
+                return null;
+            query = bodyOf(cte).ctequery;
+            alias = bodyOf(f).alias?.aliasname ?? bodyOf(f).relname;
+        }
+        if (query === undefined || alias === undefined || kindOf(query) !== "SelectStmt")
+            return null;
+        if (bodyOf(f).alias?.colnames !== undefined)
+            return null;
+        const targets = (b.targetList ?? []);
+        if (targets.some((t) => this.hasAggregate(bodyOf(t).val)))
+            return null;
+        if (targets.length === 1 && hasStar(bodyOf(targets[0]).val))
+            return { query, alias, columns: "star" };
+        const outputs = this.outputNames(query);
+        if (outputs === null)
+            return null;
+        const columns = targets.map((t) => {
+            const v = bodyOf(t).val;
+            if (kindOf(v) !== "ColumnRef" || hasStar(v))
+                return -1;
+            const f = names(bodyOf(v).fields);
+            const at = outputs.indexOf(f[f.length - 1]);
+            return at >= 0 && outputs.lastIndexOf(f[f.length - 1]) === at ? at : -1;
+        });
+        return { query, alias, columns };
+    }
+    /** the query a `SELECT * FROM (q) s` passes through whole, or null: its output names and types are q's (a BI tool's
+     *  `SELECT "sql".* FROM (…) AS "sql"` inside a query that names a column of it) */
+    starOf(b) {
+        const through = this.passThrough(b);
+        return through !== null && through.columns === "star" ? through.query : null;
+    }
+    /** a query's output column names, as Postgres names them (a set operation's are its first arm's) */
+    outputNames(q) {
+        let b = bodyOf(q);
+        while (b.op !== undefined && b.op !== "SETOP_NONE" && b.larg !== undefined)
+            b = b.larg;
+        const star = this.starOf(b);
+        if (star !== null)
+            return this.outputNames(star);
+        const targets = (b.targetList ?? []);
+        if (targets.some((t) => hasStar(bodyOf(t).val)))
+            return null;
+        return targets.map((t) => bodyOf(t).name ?? figureColname(bodyOf(t).val));
+    }
+    /** a query's output columns' types, as Postgres analysed them (a set operation's: its first arm's) */
+    outputFields(q) {
+        let b = bodyOf(q);
+        while (b.op !== undefined && b.op !== "SETOP_NONE" && b.larg !== undefined)
+            b = b.larg;
+        const star = this.starOf(b);
+        if (star !== null)
+            return this.outputFields(star);
+        const targets = (b.targetList ?? []);
+        const out = targets.map((t) => { const x = this.typed(bodyOf(t).val); return x === null ? null : { oid: x.type, typmod: x.typmod }; });
+        return out.some((x) => x === null) ? null : out;
+    }
+    /** whether an expression holds an aggregate (outside a subquery) */
+    hasAggregate(v) {
+        if (Array.isArray(v))
+            return v.some((x) => this.hasAggregate(x));
+        if (v === null || typeof v !== "object")
+            return false;
+        if (isNode(v)) {
+            if (kindOf(v) === "SubLink")
+                return false;
+            if (kindOf(v) === "FuncCall" && bodyOf(v).over === undefined && this.typed(v)?.node === "AGGREF")
+                return true;
+            return Object.values(bodyOf(v)).some((x) => this.hasAggregate(x));
+        }
+        return Object.values(v).some((x) => this.hasAggregate(x));
+    }
+    /** whether a cell can be selected on its own in a grouped SELECT: a GROUP BY expression, an aggregate or a window
+     *  function, a constant, or built of those */
+    validGrouped(n, groupShapes) {
+        if (groupShapes.has(shapeOf(n)))
+            return true;
+        const k = kindOf(n);
+        if (k === "A_Const")
+            return true;
+        // a column of this query Postgres accepted outside the GROUP BY is one the group's key decides: valid, and read
+        // through any_value when the walk reaches its cell (decidedByKey)
+        if (k === "ColumnRef") {
+            const t = this.typed(n);
+            return t?.node === "VAR" && t.levelsUp === 0;
+        }
+        if (k === "SubLink")
+            return false;
+        if (k === "FuncCall" && (bodyOf(n).over !== undefined || this.typed(n)?.node === "AGGREF"))
+            return true;
+        const children = Object.values(bodyOf(n)).flatMap((x) => Array.isArray(x) ? x : [x]).filter(isNode);
+        return children.every((c) => this.validGrouped(c, groupShapes));
+    }
+    /** An expression as a program over cells (`cell` makes one), or null where it is not a numeric Postgres's rules
+     *  decide here; `kind` int where the value is an integer (integer arithmetic is DuckDB's, one cell). */
+    exactOf(n, cell) {
+        const k = kindOf(n), b = bodyOf(n);
+        const type = this.typeOf(n);
+        const asCell = () => type !== null && INTEGERS.has(type) ? { p: cell(n), kind: "int" } : type === NUMERIC ? { p: this.padded(n, cell(n)), kind: "numeric" } : null;
+        const numeric = (p) => ({ p, kind: "numeric" });
+        const sub = (x) => isNode(x) ? this.exactOf(x, cell) : null;
+        switch (k) {
+            // a numeric parameter is its bound text, as Postgres reads it (DuckDB is given it as a double: 15 digits)
+            case "ParamRef": return type === NUMERIC ? numeric({ op: "cell", key: `$${b.number}` }) : asCell();
+            case "A_Const": {
+                if (b.ival !== undefined)
+                    return { p: { op: "literal", text: String(b.ival.ival ?? 0) }, kind: "int" };
+                if (b.fval !== undefined)
+                    return numeric({ op: "literal", text: positional(String(b.fval.fval)) });
+                const v = constString(n);
+                const literal = v !== null && type === NUMERIC ? numericLiteral(v) : null;
+                if (literal !== null)
+                    return numeric({ op: "literal", text: literal });
+                return null;
+            }
+            case "A_Expr": {
+                const name = lastName(b.name);
+                if (b.kind !== "AEXPR_OP" || !["+", "-", "*", "/", "%"].includes(name))
+                    return asCell();
+                if (type !== NUMERIC)
+                    return asCell();
+                if (b.lexpr === undefined) {
+                    const r = sub(b.rexpr);
+                    return r === null ? null : name === "-" ? numeric({ op: "neg", arg: r.p }) : r;
+                }
+                const l = sub(b.lexpr), r = sub(b.rexpr);
+                if (l === null || r === null)
+                    return null;
+                const ops = { "+": "add", "-": "sub", "*": "mul", "/": "div", "%": "mod" };
+                return numeric({ op: ops[name], args: [l.p, r.p] });
+            }
+            case "TypeCast": {
+                const target = lastName(b.typeName?.names);
+                if (target !== "numeric" && target !== "decimal")
+                    return asCell();
+                const arg = b.arg;
+                const from = this.typeOf(arg);
+                const inner = from !== null && FLOATS.has(from) ? numeric(cell(arg, from === FLOAT4 ? "float4" : "float8"))
+                    // a text: the digits Postgres's numeric_in reads (`1.50` keeps its scale, `1_000.5` is 1000.5)
+                    : from !== null && TEXTS.has(from) && from !== UNKNOWN && constString(arg) === null ? numeric(cell(pgCall("text", "a1::numeric", [this.clone(arg)]), "text"))
+                        : sub(arg);
+                if (inner === null)
+                    return null;
+                const mods = (b.typeName?.typmods ?? []).map((m) => constInt(m));
+                if (mods.length === 0)
+                    return numeric(inner.p);
+                if (mods.some((m) => m === null))
+                    return null;
+                return numeric({ op: "typmod", arg: inner.p, precision: mods[0], scale: mods[1] ?? 0 });
+            }
+            case "CaseExpr": {
+                // each arm as its own program, and the arm the row took as an integer cell: the same CASE with each result its
+                // arm's number (the ELSE the last; past the arms, a CASE without one, NULL). Only the taken arm is computed, as
+                // in Postgres, and an arm's cells are read only on its rows (`CASE WHEN <its arm> THEN … END`): DuckDB computes
+                // every cell on every row, and sqrt(x) of an arm `WHEN x > 0` raised on the rest
+                if (type !== NUMERIC)
+                    return asCell();
+                const whens = (b.args ?? []);
+                const index = () => ({ CaseExpr: { ...(b.arg === undefined ? {} : { arg: this.clone(b.arg) }),
+                        args: whens.map((w, i) => ({ CaseWhen: { expr: this.clone(bodyOf(w).expr), result: intConst(i) } })), defresult: intConst(whens.length) } });
+                const onItsRows = (i) => (m, conv) => cell(kindOf(m) === "ColumnRef" || !holdsKind(m, "ColumnRef") ? m : caseWhen([[op("=", index(), intConst(i)), m]], null), conv);
+                const results = [...whens.map((w) => bodyOf(w).result), ...(b.defresult === undefined ? [] : [b.defresult])];
+                const arms = results.map((r, i) => isNode(r) ? this.exactOf(r, onItsRows(i)) : null);
+                if (arms.some((a) => a === null))
+                    return asCell();
+                return numeric({ op: "pick", index: cell(index()), args: arms.map((a) => a.p) });
+            }
+            case "MinMaxExpr":
+            case "CoalesceExpr": {
+                if (type !== NUMERIC)
+                    return asCell();
+                const args = (b.args ?? []).map(sub);
+                if (args.some((a) => a === null))
+                    return null;
+                const opName = k === "CoalesceExpr" ? "coalesce" : b.op === "IS_GREATEST" ? "greatest" : "least";
+                return numeric({ op: opName, args: args.map((a) => a.p) });
+            }
+            case "FuncCall": {
+                const name = lastName(b.funcname);
+                const args = (b.args ?? []);
+                const plain = b.over === undefined && b.agg_within_group !== true;
+                if (type !== NUMERIC)
+                    return asCell();
+                switch (name) {
+                    case "round":
+                    case "trunc": {
+                        if (!plain || args.length < 1 || args.length > 2)
+                            return asCell();
+                        const x = sub(args[0]);
+                        const scale = args.length === 2 ? constInt(args[1]) : 0;
+                        if (x === null || scale === null)
+                            return asCell();
+                        return numeric({ op: name, arg: x.p, scale });
+                    }
+                    case "abs":
+                    case "floor":
+                    case "ceil":
+                    case "ceiling": {
+                        const x = args.length === 1 ? sub(args[0]) : null;
+                        return x === null ? asCell() : numeric({ op: name === "ceiling" ? "ceil" : name, arg: x.p });
+                    }
+                    case "mod": {
+                        const x = sub(args[0]), y = sub(args[1]);
+                        return x === null || y === null ? asCell() : numeric({ op: "mod", args: [x.p, y.p] });
+                    }
+                    case "ln":
+                    case "log":
+                    case "log10":
+                    case "exp":
+                    case "sqrt":
+                    case "power":
+                    case "pow": {
+                        const text = this.pgNumeric(n);
+                        return text === null ? asCell() : numeric(cell(text, "text"));
+                    }
+                    case "avg": {
+                        // Postgres's avg of an integer or a numeric is its sum divided by its count, both exact (int8_avg,
+                        // numeric_avg): DuckDB computes each, with the same DISTINCT, FILTER and window
+                        if (b.agg_within_group === true || args.length !== 1 || b.agg_star === true)
+                            return asCell();
+                        const argType = this.typeOf(args[0]);
+                        if (argType === null || !(INTEGERS.has(argType) || argType === NUMERIC))
+                            return asCell();
+                        const as = (f) => ({ FuncCall: { ...this.clone(b), funcname: [S(f)] } });
+                        const sum = as("sum");
+                        return numeric({ op: "div", args: [this.summed(b, args[0], sum, cell), cell(as("count"))] });
+                    }
+                    case "stddev":
+                    case "stddev_samp":
+                    case "stddev_pop":
+                    case "variance":
+                    case "var_samp":
+                    case "var_pop": {
+                        // Postgres's stddev and variance of an integer or a numeric are exact (numeric_stddev_internal), from N, Σx
+                        // and Σx², which DuckDB computes exactly, with the same FILTER and window. Not DISTINCT: the distinct values'
+                        // squares are not the distinct squares (-1 and 1)
+                        if (b.agg_within_group === true || args.length !== 1 || b.agg_star === true || b.agg_distinct === true)
+                            return asCell();
+                        const argType = this.typeOf(args[0]);
+                        if (argType === null || !(INTEGERS.has(argType) || argType === NUMERIC))
+                            return asCell();
+                        // a numeric only where its type bounds its digits: numeric(p ≤ 18, s), read as its unscaled bigint (x·10^s).
+                        // An unconstrained one (copied at the widest scale its values use) or a wider one could overflow DuckDB's 38
+                        // digits, where Postgres answers: DuckDB's double, the numeric-stddev gap
+                        const typmod = this.typed(n)?.args[0]?.typmod ?? -1;
+                        const precision = typmod >= 4 ? ((typmod - 4) >> 16) & 0xffff : null, scale = typmod >= 4 ? (typmod - 4) & 0xffff : 0;
+                        if (argType === NUMERIC && (precision === null || precision > 18))
+                            return asCell();
+                        const as = (f, arg) => ({ FuncCall: { ...this.clone(b), funcname: [S(f)], ...(arg === undefined ? {} : { args: [arg] }) } });
+                        const x = args[0];
+                        const sum = as("sum");
+                        // x² of an int2 or int4 as a HUGEINT
+                        const squares = () => cell(as("sum", op("*", cast(this.clone(x), ["hugeint"]), cast(this.clone(x), ["hugeint"]))));
+                        // a bigint's squares may pass a HUGEINT's 1.7e38 (two near 2^63): u = h·2^32 + l, so Σu² = Σh²·2^64 +
+                        // Σhl·2^33 + Σl², three sums that fit; a numeric(p ≤ 18, s) is u·10^-s, its Σx² that times 10^-2s
+                        const splitSquares = (u, s) => {
+                            const h = () => cast(op(">>", u(), intConst(32)), ["hugeint"]);
+                            const l = () => cast(op("&", u(), numConst("4294967295")), ["hugeint"]);
+                            const term = (a, c, by) => ({ op: "mul", args: [cell(as("sum", op("*", a, c))), { op: "literal", text: String(by) }] });
+                            const whole = { op: "add", args: [term(h(), h(), 2n ** 64n), { op: "add", args: [term(h(), l(), 2n ** 33n), term(l(), l(), 1n)] }] };
+                            return s === 0 ? whole : { op: "mul", args: [whole, { op: "literal", text: `0.${"0".repeat(2 * s - 1)}1` }] };
+                        };
+                        // the unscaled value: exact, as the copy holds a numeric(p, s) with at most s decimals
+                        const unscaled = () => cast(op("*", this.clone(x), cast(scale <= 9 ? intConst(10 ** scale) : numConst(String(10n ** BigInt(scale))), ["decimal", "38", "0"])), ["bigint"]);
+                        const sumX2 = argType === NUMERIC ? splitSquares(unscaled, scale) : argType === INT8 ? splitSquares(() => this.clone(x), 0) : squares();
+                        return numeric({ op: "stddev", args: [cell(as("count")), this.padded(sum, cell(sum)), sumX2],
+                            sample: !name.endsWith("_pop"), variance: name.startsWith("var") });
+                    }
+                    case "sum": {
+                        // Postgres's sum of a numeric has the most decimals a value SUMMED has (add_var keeps the larger dscale): of
+                        // a CASE, the arms the rows took, where DuckDB's sum has its CASE type's — the widest arm's, taken or not
+                        // (Metabase's "sum where", `sum(CASE WHEN … THEN amount ELSE 0.0 END)`, read 5.0 for 5)
+                        if (args.length !== 1 || b.agg_star === true || b.agg_within_group === true || this.typeOf(args[0]) !== NUMERIC)
+                            return asCell();
+                        return numeric(this.summed(b, args[0], n, cell));
+                    }
+                    case "min":
+                    case "max": {
+                        // Postgres's min / max of a numeric is one row's value, with that row's scale (numeric_smaller). Of an
+                        // expression computed here (a quotient), DuckDB picks the row — by its value as DuckDB has it (a quotient's
+                        // double orders as Postgres's numerics, __mason_numeric_div), its operands breaking a tie, so every operand
+                        // is the same row's — and the program computes that row's operands. A NULL operand is kept (_null): a
+                        // coalesce may read it. Of equal values whose scales differ, Postgres keeps the last it reads (scan order),
+                        // Mason the one whose operands are least (greatest for max): docs/SQL-SUPPORT.md `min-max-scale-tie`
+                        if (!plain || args.length !== 1 || b.agg_star === true || this.typeOf(args[0]) !== NUMERIC)
+                            return asCell();
+                        const operands = [];
+                        const probe = this.exactOf(args[0], (m) => { operands.push(m); return { op: "cell", key: String(operands.length - 1) }; });
+                        // a column's own min is DuckDB's exact decimal, padded to its scale
+                        if (probe === null || probe.p.op === "cell" || (probe.p.op === "pad" && probe.p.arg.op === "cell") || !worthComputing(probe.p))
+                            return asCell();
+                        const key = caseWhen([[isNotNull(this.clone(args[0])), row([this.clone(args[0]), ...operands.map((m) => this.clone(m))])]], null);
+                        const picked = (m) => {
+                            const call = fn(name === "min" ? "arg_min_null" : "arg_max_null", [this.clone(m), this.clone(key)], b.agg_filter === undefined ? {} : { agg_filter: this.clone(b.agg_filter) });
+                            // an aggregate, as the grouping checks read it (validGrouped, decidedByKey), typed as the operand it picks
+                            const t = this.typed(m);
+                            this.synthetic.set(bodyOf(call), { node: "AGGREF", type: t?.type ?? NUMERIC, typmod: t?.typmod ?? -1, args: [], oid: null, format: null,
+                                collation: t?.collation ?? 0, inputCollation: 0, levelsUp: null, datum: null, qualifier: null, renamed: null });
+                            return call;
+                        };
+                        const built = this.exactOf(args[0], (m, conv) => cell(picked(m), conv));
+                        return built === null ? asCell() : numeric(built.p);
+                    }
+                    default: return asCell();
+                }
+            }
+            default: return asCell();
+        }
+    }
+    /** a numeric cell at Postgres's display scale where its types decide one (`displayScale`): DuckDB may hold the value
+     *  with fewer decimals (a numeric(65,30) is copied at the decimals its values use, src/duck/sync.ts) */
+    padded(n, p) {
+        const scale = this.displayScale(n);
+        return scale !== null && scale > 0 ? { op: "pad", arg: p, scale } : p;
+    }
+    /**
+     * A numeric sum (`sum`, DuckDB's sum of `x` with the aggregate `agg`'s DISTINCT, FILTER and window) at Postgres's
+     * scale: the types' where they decide it (`padded`); where the rows do (`rowScale`: a CASE's arms, a coalesce), the
+     * most decimals a value summed has, DuckDB's max of each row's scale beside its sum, under the same FILTER and
+     * window. Not of DISTINCT values: of 5 and 5.0 Postgres keeps one, and which is its sort's
+     * (docs/SQL-SUPPORT.md `mixed-scale-numeric`)
+     */
+    summed(agg, x, sum, cell) {
+        if (this.displayScale(x) !== null || agg.agg_distinct === true)
+            return this.padded(sum, cell(sum));
+        // a text read as an unconstrained numeric (Metabase's every JSON number), an ln or a sqrt: DuckDB holds it as a
+        // double, so it is summed as Postgres computes it (`pgNumeric`), in two exact DECIMAL(38,18) parts (a value they cannot hold refused, `numeric-exact-sum`), at the
+        // most decimals a row's text has. A sum holding a NaN or an infinity is the double's (NaN, ±Infinity, as Postgres adds
+        // them)
+        const text = this.pgNumeric(x);
+        if (text !== null) {
+            const read = () => this.clone(text);
+            const aggregate = (name, arg, type) => {
+                const n = { FuncCall: { ...this.clone(agg), funcname: [S(name)], args: [arg] } };
+                this.synthetic.set(bodyOf(n), { node: "AGGREF", type, typmod: -1, args: [], oid: null, format: null, collation: 0, inputCollation: 0,
+                    levelsUp: null, datum: null, qualifier: null, renamed: null });
+                return n;
+            };
+            const part = (i) => cell(aggregate("sum", cast(fn("__mason_numeric_exact", [read(), intConst(i)]), ["decimal", "38", "18"]), NUMERIC));
+            const exact = { op: "add", args: [part(0), { op: "mul", args: [part(1), { op: "literal", text: `0.${"0".repeat(17)}1` }] }] };
+            const scales = aggregate("max", fn("__mason_numeric_scale", [read()]), INT4);
+            const special = { CoalesceExpr: { args: [aggregate("max", cast(fn("__mason_numeric_special", [read()]), ["integer"]), INT4), intConst(0)] } };
+            return { op: "pick", index: cell(special), args: [{ op: "rescale", arg: exact, scale: cell(scales) }, cell(sum, "float8")] };
+        }
+        const scale = this.rowScale(x);
+        if (scale === null)
+            return this.padded(sum, cell(sum));
+        const most = { FuncCall: { ...this.clone(agg), funcname: [S("max")], args: [caseWhen([[isNotNull(this.clone(x)), scale]], null)] } };
+        // an aggregate, as the grouping checks read it (validGrouped, decidedByKey)
+        this.synthetic.set(bodyOf(most), { node: "AGGREF", type: INT4, typmod: -1, args: [], oid: null, format: null, collation: 0, inputCollation: 0,
+            levelsUp: null, datum: null, qualifier: null, renamed: null });
+        return { op: "rescale", arg: cell(sum), scale: cell(most) };
+    }
+    /**
+     * A numeric DuckDB answers as a double whose every row's value Postgres's own function computes (src/duck/pg-eval.ts),
+     * as numeric_out writes it: a text read as an unconstrained numeric (`(j ->> 'k')::numeric`), and ln, log, exp, sqrt
+     * and power, whose digits follow a scale from the argument's own (numeric.c's ln_var, power_var) — each argument at
+     * the scale Postgres gives it: a numeric(p, s) or an expression its types decide at s (DuckDB may hold fewer decimals:
+     * src/duck/sync.ts), an integer whole, a literal as written, a column of no declared scale at the decimals the copy
+     * holds (`mixed-scale-numeric`). Null for anything else.
+     */
+    pgNumeric(n) {
+        const b = bodyOf(n);
+        if (kindOf(n) === "TypeCast") {
+            const target = lastName(b.typeName?.names);
+            if ((target !== "numeric" && target !== "decimal") || (b.typeName?.typmods ?? []).length > 0 || !isNode(b.arg))
+                return null;
+            const from = this.typeOf(b.arg);
+            return from !== null && TEXTS.has(from) && from !== UNKNOWN && constString(b.arg) === null ? pgCall("text", "a1::numeric", [this.clone(b.arg)]) : null;
+        }
+        const name = kindOf(n) === "FuncCall" ? lastName(b.funcname) : "";
+        const args = (b.args ?? []);
+        if (!["ln", "log", "log10", "exp", "sqrt", "power", "pow"].includes(name) || this.typeOf(n) !== NUMERIC || b.over !== undefined || args.length < 1 || args.length > 2)
+            return null;
+        // an argument computed here (a quotient): its exact value, the program DuckDB evaluates row by row
+        const read = args.map((a) => {
+            const own = this.typed(a);
+            if (own !== null && INTEGERS.has(own.type))
+                return ["numeric", this.clone(a)];
+            const scale = this.displayScale(a);
+            if (scale !== null)
+                return [`numeric(1000, ${scale})`, this.clone(a)];
+            if (kindOf(a) === "ColumnRef" && own?.type === NUMERIC)
+                return ["numeric", this.clone(a)];
+            const exact = this.exactText(a);
+            return exact === null ? null : ["numeric", exact];
+        });
+        if (read.some((x) => x === null)) {
+            throw new Unrewritable(`${name}() of a numeric Mason cannot compute exactly is not supported by Mason`, `cast the argument to numeric(p, s): ${name}(x::numeric(20, 4))`, "numeric-math");
+        }
+        return pgCall("text", `${name}(${read.map((x, i) => `a${i + 1}::${x[0]}`).join(", ")})`, read.map((x) => x[1]));
+    }
+    /** whether DuckDB holds an expression's value exactly (an integer, or a DECIMAL its types decide): a column, an
+     *  expression of declared scales, a sum / min / max of one, a count; a CASE the rewrite made of such arms (an exact
+     *  program's arm index, a cell on its arm's rows). Not what DuckDB computes as a double (`^`, a quotient). */
+    duckExact(n) {
+        const t = this.typed(n), b = bodyOf(n);
+        if (t !== null && INTEGERS.has(t.type))
+            return true;
+        if (kindOf(n) === "ColumnRef")
+            return t !== null && t.type === NUMERIC;
+        if (this.displayScale(n) !== null)
+            return true;
+        const args = (b.args ?? []);
+        // a count (an avg's, made from the avg's node, carries the avg's type)
+        if (kindOf(n) === "FuncCall" && lastName(b.funcname) === "count")
+            return true;
+        if (kindOf(n) === "FuncCall" && ["sum", "min", "max", "any_value"].includes(lastName(b.funcname)) && args.length === 1)
+            return this.duckExact(args[0]);
+        if (kindOf(n) === "CaseExpr" && t === null)
+            return [...args.map((w) => bodyOf(w).result), ...(b.defresult === undefined ? [] : [b.defresult])].every((r) => isNode(r) && this.duckExact(r));
+        return false;
+    }
+    /** a numeric's exact text, row by row: its program (exactOf) evaluated by DuckDB over its cells' texts
+     *  (`__mason_numeric_program`, src/duck/functions.ts); null where there is none, or it reads a parameter */
+    exactText(n) {
+        const cells = [];
+        let built;
+        try {
+            built = this.exactOf(n, (m, conv = "exact") => { cells.push({ node: m, conv }); return { op: "cell", key: String(cells.length - 1) }; });
+        }
+        catch (e) {
+            if (e === NOT_EXACT)
+                return null;
+            throw e;
+        }
+        if (built === null || cellsOfProgram(built.p).some((k) => k.startsWith("$")))
+            return null;
+        if (cells.some((c) => c.conv === "exact" && !this.duckExact(c.node)))
+            return null;
+        const texts = cells.map((c) => c.conv === "text" ? this.clone(c.node) : c.conv === "exact" ? cast(this.clone(c.node), ["varchar"])
+            : fn("__mason_float_numeric_text", [cast(this.clone(c.node), ["double"]), boolConst(c.conv === "float4")]));
+        return fn("__mason_numeric_program", [strConst(JSON.stringify(built.p)), ...texts]);
+    }
+    /**
+     * The decimals Postgres writes for one ROW's value of a numeric expression, as DuckDB computes them (an integer), where
+     * the arm a row took decides them: a CASE's arms, a coalesce's first value that is not NULL, + - * over those
+     * (numeric.c's add_var, mul_var). Null where a value's own digits decide (an unconstrained column, a division).
+     */
+    rowScale(n) {
+        const fixed = this.displayScale(n);
+        if (fixed !== null)
+            return intConst(fixed);
+        const k = kindOf(n), b = bodyOf(n);
+        const of = (x) => isNode(x) ? this.rowScale(x) : null;
+        switch (k) {
+            case "CaseExpr": {
+                const whens = (b.args ?? []);
+                const results = whens.map((w) => of(bodyOf(w).result));
+                const otherwise = b.defresult === undefined ? nullConst() : of(b.defresult);
+                if (results.some((r) => r === null) || otherwise === null)
+                    return null;
+                return { CaseExpr: { ...(b.arg === undefined ? {} : { arg: this.clone(b.arg) }),
+                        args: whens.map((w, i) => ({ CaseWhen: { expr: this.clone(bodyOf(w).expr), result: results[i] } })), defresult: otherwise } };
+            }
+            case "CoalesceExpr": {
+                const args = (b.args ?? []);
+                const scales = args.map(of);
+                if (scales.some((r) => r === null))
+                    return null;
+                return caseWhen(args.map((a, i) => [isNotNull(this.clone(a)), scales[i]]), null);
+            }
+            case "A_Expr": {
+                if (b.kind !== "AEXPR_OP")
+                    return null;
+                const name = lastName(b.name);
+                const r = of(b.rexpr);
+                if (b.lexpr === undefined)
+                    return name === "-" || name === "+" ? r : null;
+                const l = of(b.lexpr);
+                if (l === null || r === null)
+                    return null;
+                return name === "+" || name === "-" ? fn("greatest", [l, r]) : name === "*" ? op("+", l, r) : null;
+            }
+            case "TypeCast": {
+                const target = lastName(b.typeName?.names);
+                return (target === "numeric" || target === "decimal") && (b.typeName?.typmods ?? []).length === 0 && isNode(b.arg) && this.typeOf(b.arg) === NUMERIC ? of(b.arg) : null;
+            }
+            default: return null;
+        }
+    }
+    /**
+     * The decimals Postgres writes for an expression's every value, where its types alone decide them: a numeric(p, s)
+     * column's s, a literal's own, a sum / min / max of one, + and - the larger, * the sum (numeric.c's add_var, mul_var).
+     * Null where the values decide (an unconstrained column, a division): DuckDB's own scale stands there.
+     */
+    displayScale(n) {
+        const k = kindOf(n), b = bodyOf(n);
+        const t = this.typed(n);
+        if (t !== null && INTEGERS.has(t.type))
+            return 0;
+        switch (k) {
+            case "ColumnRef": return t !== null && t.type === NUMERIC && t.typmod >= 4 ? (t.typmod - 4) & 0xffff : null;
+            case "A_Const": return b.ival !== undefined ? 0 : b.fval !== undefined ? (positional(String(b.fval.fval)).split(".")[1] ?? "").length : null;
+            case "A_Expr": {
+                if (b.kind !== "AEXPR_OP")
+                    return null;
+                const name = lastName(b.name);
+                const r = isNode(b.rexpr) ? this.displayScale(b.rexpr) : null;
+                if (b.lexpr === undefined)
+                    return name === "-" || name === "+" ? r : null;
+                const l = isNode(b.lexpr) ? this.displayScale(b.lexpr) : null;
+                if (l === null || r === null)
+                    return null;
+                return name === "+" || name === "-" ? Math.max(l, r) : name === "*" ? l + r : null;
+            }
+            case "FuncCall": {
+                const args = (b.args ?? []);
+                if (!["sum", "min", "max"].includes(lastName(b.funcname)) || args.length !== 1 || b.agg_star === true || b.agg_within_group === true)
+                    return null;
+                return this.displayScale(args[0]);
+            }
+            case "TypeCast": {
+                const target = lastName(b.typeName?.names);
+                if (target !== "numeric" && target !== "decimal")
+                    return null;
+                const mods = (b.typeName?.typmods ?? []).map((m) => constInt(m));
+                if (mods.length === 0) {
+                    if (!isNode(b.arg))
+                        return null;
+                    const from = this.typeOf(b.arg);
+                    // an integer is whole; a literal text has the decimals it is written with (`'1.50'::numeric`)
+                    if (from !== null && INTEGERS.has(from))
+                        return 0;
+                    const literal = constString(b.arg) === null ? null : numericLiteral(constString(b.arg));
+                    if (literal !== null)
+                        return (literal.split(".")[1] ?? "").length;
+                    return from === NUMERIC ? this.displayScale(b.arg) : null;
+                }
+                return mods.some((m) => m === null) ? null : mods[1] ?? 0;
+            }
+            default: return null;
+        }
+    }
+    // ------------------------------------------------------------------------------------- sorting and collation
+    /** the collation a text expression compares under, as DuckDB follows it; null for a type that is no text */
+    textCollation(n) {
+        if (kindOf(n) === "CollateClause")
+            return this.namedCollation(lastName(bodyOf(n).collname));
+        const t = this.typed(n);
+        if (t === null || !TEXTS.has(t.type))
+            return null;
+        if (BYTE_COLLATIONS.has(t.collation))
+            return { kind: "bytes" };
+        return this.collation;
+    }
+    namedCollation(name) {
+        if (["c", "posix", "ucs_basic", "pg_c_utf8"].includes(name))
+            return { kind: "bytes" };
+        if (name === "default")
+            return this.collation;
+        // Postgres's `unicode` is ICU's root locale, `und-x-icu` by another name
+        if (name === "unicode")
+            return { kind: "icu", name: "en_us" };
+        const icu = /^(.*)-x-icu$/.exec(name);
+        if (icu)
+            return { kind: "icu", name: icu[1] === "und" ? "en_us" : icu[1].replace(/-/g, "_") };
+        throw new Unrewritable(`collation "${name}" is not supported by Mason`, `write COLLATE "C" for byte order, or leave the COLLATE out for the database's`, "collation-unknown");
+    }
+    /** the keys DuckDB sorts by for one text expression under a collation */
+    sortKeys(e, c) {
+        const plain = kindOf(e) === "CollateClause" ? bodyOf(e).arg : e;
+        switch (c.kind) {
+            case "bytes": return [plain];
+            case "icu": return [collate(plain, c.name)];
+            case "libc": return libcKeys(this.cp, plain, c.icu);
+        }
+    }
+    /** a SortBy: its expression's sort keys under its collation (several under a libc one), each with its direction */
+    sortBy(b, targets, select) {
+        let e = b.node;
+        if (targets !== null) {
+            const n = constInt(e);
+            if (n !== null && n >= 1 && n <= targets.length)
+                e = this.clone(bodyOf(targets[n - 1]).val);
+            else if (kindOf(e) === "ColumnRef") {
+                const f = names(bodyOf(e).fields);
+                const named = f.length === 1 ? targets.filter((t) => bodyOf(t).name === f[0]) : [];
+                if (named.length === 1)
+                    e = this.clone(bodyOf(named[0]).val);
+            }
+        }
+        // a derived table's column read through `s.*` (`SELECT s.* FROM (…) AS s ORDER BY s.pod`, a tool's wrapper): Postgres
+        // analysed the ORDER BY as the star's expansion, at no offset of its own, so the column has no type here — it is the
+        // subquery's target of that name, whose type and collation decide the order (a review finding: sorted by bytes)
+        if (kindOf(e) === "ColumnRef" && select !== null && this.typed(e) === null) {
+            const target = this.derivedTarget(e, select);
+            if (target !== null)
+                this.typedLike.set(bodyOf(e), target);
+        }
+        const type = this.typeOf(e);
+        if (type === INET)
+            throw new Unrewritable("ORDER BY an inet value is not supported by Mason (Postgres orders addresses by network, then host)", "sort by another column", "inet-order");
+        // a citext sorts by its lower-cased text under the database's collation (citext_cmp)
+        if (this.isCitext(type)) {
+            e = this.foldCitext(e);
+            b.node = e;
+        }
+        this.comparable(e, "ORDER BY");
+        const c = this.textCollation(e);
+        // a char(n) sorts without its padding (bpcharcmp)
+        if (this.typeOf(e) === BPCHAR) {
+            e = fn("rtrim", [e]);
+            this.typedLike.set(bodyOf(e), b.node);
+            b.node = e;
+        }
+        if (c === null || (c.kind === "bytes" && kindOf(b.node) !== "CollateClause"))
+            return null;
+        return this.sortKeys(e, c).map((k) => ({ SortBy: { ...b, node: k } }));
+    }
+    /** the target a derived table's column names (`s.pod`, or `pod` where one derived table is read): the subquery's or
+     *  the CTE's target with that output name, when there is exactly one; null for a base table's column or an ambiguity */
+    /** the FROM's subqueries and CTE references, by alias (a column list renames them: left out) */
+    fromSources(select) {
+        const sources = [];
+        const visit = (x) => {
+            if (kindOf(x) === "JoinExpr") {
+                for (const side of [bodyOf(x).larg, bodyOf(x).rarg])
+                    if (isNode(side))
+                        visit(side);
+                return;
+            }
+            if (kindOf(x) === "RangeSubselect") {
+                const a = bodyOf(x).alias?.aliasname;
+                if (typeof a === "string" && isNode(bodyOf(x).subquery) && bodyOf(x).alias?.colnames === undefined)
+                    sources.push({ alias: a, query: bodyOf(x).subquery });
+                return;
+            }
+            if (kindOf(x) === "RangeVar" && bodyOf(x).schemaname === undefined && bodyOf(x).alias?.colnames === undefined) {
+                const cte = this.ctes.get(String(bodyOf(x).relname));
+                if (cte !== undefined)
+                    sources.push({ alias: bodyOf(x).alias?.aliasname ?? String(bodyOf(x).relname), query: cte });
+            }
+        };
+        for (const x of (select.fromClause ?? []))
+            if (isNode(x))
+                visit(x);
+        return sources;
+    }
+    derivedTarget(ref, select) {
+        const f = names(bodyOf(ref).fields);
+        if (f.length === 0 || f.length > 2)
+            return null;
+        const col = f[f.length - 1], alias = f.length === 2 ? f[0] : undefined;
+        const sources = this.fromSources(select);
+        const matching = alias === undefined ? sources : sources.filter((q) => q.alias === alias);
+        if (matching.length !== 1)
+            return null;
+        let q = bodyOf(matching[0].query);
+        while (q.op !== undefined && q.op !== "SETOP_NONE" && q.larg !== undefined)
+            q = q.larg;
+        const hits = (q.targetList ?? []).filter((t) => isNode(bodyOf(t).val) && !hasStar(bodyOf(t).val) && (bodyOf(t).name ?? figureColname(bodyOf(t).val)) === col);
+        return hits.length === 1 ? bodyOf(hits[0]).val : null;
+    }
+    /** a GROUP BY item as the expression it groups: an ordinal or an output name is that target's */
+    groupedExpression(g, b) {
+        const targets = (b.targetList ?? []);
+        const n = constInt(g);
+        if (n !== null && n >= 1 && n <= targets.length)
+            return bodyOf(targets[n - 1]).val;
+        if (kindOf(g) === "ColumnRef") {
+            const f = names(bodyOf(g).fields);
+            const named = f.length === 1 && this.typed(g) === null ? targets.filter((t) => bodyOf(t).name === f[0]) : [];
+            if (named.length === 1)
+                return bodyOf(named[0]).val;
+        }
+        return g;
+    }
+    /** a value Mason cannot sort, group or compare as Postgres does: jsonb (Postgres's own order and equality), a text
+     *  array under the database's collation (each element under it) — refused, where a statement would need it */
+    comparable(n, where) {
+        const type = this.typeOf(n);
+        if (this.isCitext(type))
+            throw new Unrewritable(`${where} a citext value is not supported by Mason (Postgres groups and sorts it without regard to case)`, "GROUP BY lower(x), or x::text where case matters", "citext-forms");
+        if (type === JSONB)
+            throw new Unrewritable(`${where} a jsonb value is not supported by Mason (Postgres orders and equates jsonb by its own rules)`, "compare a member (j ->> 'k'), or j::text", "jsonb-compare");
+        if ((type === 1009 || type === 1015) && this.collation.kind !== "bytes")
+            throw new Unrewritable(`${where} a text array is not supported by Mason under the database's collation`, "sort by an element (a[1]) or by array_to_string(a, ',')", "text-array-order");
+    }
+    collateClause(b) {
+        // an expression's own COLLATE outside a sort: a comparison's is handled at the comparison; C needs nothing
+        const c = this.namedCollation(lastName(b.collname));
+        if (c.kind === "bytes")
+            return b.arg;
+        if (c.kind === "icu") {
+            b.collname = [S(c.name)];
+            return null;
+        }
+        return null;
+    }
+    /** a text comparison under the collation: `a < b` compares their keys */
+    compareText(name, l, r, c) {
+        if (c.kind === "icu")
+            return op(name, collate(strip(l), c.name), collate(strip(r), c.name));
+        if (c.kind === "libc")
+            return op(name, libcKey(this.cp, strip(l), c.icu), libcKey(this.cp, strip(r), c.icu));
+        return op(name, l, r);
+    }
+    minMax(b) {
+        // GREATEST / LEAST of text compare under the collation
+        const t = this.at(b, ["MINMAXEXPR"]);
+        if (t !== null)
+            b.args = b.args.map((a, i) => this.widen(a, t.args[i]?.type));
+        if (t === null || !TEXTS.has(t.type) || BYTE_COLLATIONS.has(t.inputCollation) || this.collation.kind === "bytes")
+            return null;
+        if (this.collation.kind === "libc") {
+            // the greatest (least) of the values' keys, which end in the value's own bytes: the value is read back from them
+            const icu = this.collation.icu;
+            const keys = b.args.map((a) => libcKey(this.cp, strip(a), icu));
+            const best = { MinMaxExpr: { ...b, args: keys } };
+            this.done.add(bodyOf(best));
+            return fn("decode", [fn("unhex", [fn("regexp_extract", [best, strConst("[^ ]*$")])])]);
+        }
+        const name = this.collation.name;
+        b.args = b.args.map((a) => collate(a, name));
+        return null;
+    }
+    // --------------------------------------------------------------------------------------------- operators
+    aExpr(b) {
+        const name = lastName(b.name);
+        const t = this.typed({ A_Expr: b });
+        let l = b.lexpr, r = b.rexpr;
+        const args = t?.args ?? [];
+        const a0 = args[0]?.type ?? null, a1 = args[1]?.type ?? null;
+        // jsonb's jsonpath operators: Postgres's answer for each row (src/duck/pg-eval.ts)
+        if (b.kind === "AEXPR_OP" && (name === "@?" || name === "@@") && a0 === JSONB && l !== undefined && r !== undefined)
+            return pgCall("bool", `a1::jsonb ${name} a2::jsonpath`, [l, r]);
+        if ((b.kind === "AEXPR_OP_ANY" || b.kind === "AEXPR_OP_ALL") && this.isCitext(a0)) {
+            throw new Unrewritable("a citext compared with ANY or ALL of an array is not supported by Mason", "x IN (…) with the values written out, or lower(x) = ANY (…)", "citext-forms");
+        }
+        switch (b.kind) {
+            case "AEXPR_LIKE":
+            case "AEXPR_ILIKE": {
+                // DuckDB's LIKE has no escape character unless asked; Postgres's is the backslash
+                const negated = name.startsWith("!");
+                // a citext's LIKE is case-insensitive (texticlike)
+                const ilike = b.kind === "AEXPR_ILIKE" || this.isCitext(a0);
+                let pattern = r, escape = strConst("\\");
+                if (kindOf(pattern) === "FuncCall" && lastName(bodyOf(pattern).funcname) === "like_escape") {
+                    const a = bodyOf(pattern).args;
+                    pattern = a[0];
+                    escape = a[1];
+                }
+                const call = fn(ilike ? "ilike_escape" : "like_escape", [l, pattern, escape]);
+                return negated ? not(call) : call;
+            }
+            case "AEXPR_BETWEEN":
+            case "AEXPR_NOT_BETWEEN": {
+                const bounds = (bodyOf(r).items ?? []);
+                // numbers of which one is a float are compared as double precision (float8 is Postgres's preferred numeric
+                // type: `real BETWEEN 0.1 AND 1` is float48ge and float8le), where DuckDB's common type is single precision
+                const own = [l, ...bounds].map((x) => this.typeOf(x));
+                if (own.some((x) => x !== null && FLOATS.has(x)) && own.every((x) => x !== null && NUMBER_TYPES.has(x)) && new Set(own).size > 1) {
+                    b.lexpr = cast(l, ["double"]);
+                    bodyOf(r).items = bounds.map((x) => cast(x, ["double"]));
+                    return null;
+                }
+                const c = this.textCollation(l);
+                // char(n): compared without the padding
+                const trim = (x) => this.typeOf(x) === BPCHAR ? fn("rtrim", [x]) : x;
+                if (c === null || c.kind === "bytes") {
+                    if (own.includes(BPCHAR)) {
+                        b.lexpr = trim(l);
+                        bodyOf(r).items = bounds.map(trim);
+                    }
+                    return null;
+                }
+                const inside = and([this.compareText(">=", trim(l), trim(bounds[0]), c), this.compareText("<=", trim(this.clone(l)), trim(bounds[1]), c)]);
+                return b.kind === "AEXPR_NOT_BETWEEN" ? not(inside) : inside;
+            }
+            case "AEXPR_OP_ANY":
+            case "AEXPR_OP_ALL": {
+                // x LIKE ANY (patterns): each pattern's LIKE, OR'd (ALL: AND'd) — SQL's three values are ANY's and ALL's
+                const like = { "~~": ["like_escape", false], "~~*": ["ilike_escape", false], "!~~": ["like_escape", true], "!~~*": ["ilike_escape", true] }[name];
+                if (like === undefined) {
+                    // DuckDB reads a NULL array as an empty one (ANY false, ALL true), where Postgres's answer is NULL; with a NULL
+                    // element or a NULL operand it answers as Postgres does. An array written out is never NULL
+                    if (r === undefined || kindOf(r) === "A_ArrayExpr" || constString(r) !== null || this.nullArrayTested.has(b))
+                        return null;
+                    this.nullArrayTested.add(b);
+                    return caseWhen([[isNull(this.clone(r)), nullConst()]], { A_Expr: b });
+                }
+                const literal = constString(r);
+                const patterns = r !== undefined && kindOf(r) === "A_ArrayExpr" ? (bodyOf(r).elements ?? [])
+                    : literal !== null ? arrayLiteral(literal).map((p) => p === null ? nullConst() : strConst(p)) : null;
+                if (patterns === null)
+                    throw new Unrewritable(`${like[0] === "like_escape" ? "LIKE" : "ILIKE"} ${b.kind === "AEXPR_OP_ANY" ? "ANY" : "ALL"} over an array that is not written out is not supported by Mason`, "write the patterns as ARRAY['…', '…'], or OR the LIKEs", "like-any-array");
+                const each = patterns.map((p, i) => { const m = fn(like[0], [i === 0 ? l : this.clone(l), p, strConst("\\")]); return like[1] ? not(m) : m; });
+                if (each.length === 0)
+                    return boolConst(b.kind === "AEXPR_OP_ALL");
+                return b.kind === "AEXPR_OP_ANY" ? or(each) : and(each);
+            }
+            case "AEXPR_SIMILAR": {
+                const call = bodyOf(r);
+                const a = (call.args ?? []);
+                const pattern = constString(a[0]), escape = a[1] === undefined ? "\\" : constString(a[1]);
+                if (pattern === null || escape === null)
+                    throw new Unrewritable("SIMILAR TO with a pattern or an ESCAPE that is not a literal is not supported by Mason", "write the pattern as a string literal, or use ~ with a POSIX regular expression", "similar-to-forms");
+                const m = fn("regexp_full_match", [l, strConst(`(?s)${similarToRe2(pattern, escape)}`)]);
+                return name.startsWith("!") ? not(m) : m;
+            }
+            case "AEXPR_OP": break;
+            case "AEXPR_IN": {
+                // `x IN (a, b)` is x = ANY (ARRAY[a, b]) over the type Postgres chose for both
+                const want = t?.args[0]?.type ?? null, element = t?.args[1]?.type !== undefined ? NUMBER_ELEMENT[t.args[1].type] ?? null : null;
+                // a citext IN a list: each side lower-cased (citext_eq)
+                if (this.isCitext(want) && l !== undefined && r !== undefined && kindOf(r) === "List") {
+                    b.lexpr = this.foldCitext(l);
+                    bodyOf(r).items = (bodyOf(r).items ?? []).map((x) => this.foldCitext(x));
+                    return null;
+                }
+                if (l !== undefined)
+                    this.comparable(l, "IN");
+                if (want === BPCHAR && l !== undefined && r !== undefined && kindOf(r) === "List") {
+                    b.lexpr = fn("rtrim", [l]);
+                    bodyOf(r).items = (bodyOf(r).items ?? []).map((x) => fn("rtrim", [x]));
+                    return null;
+                }
+                if (l !== undefined)
+                    b.lexpr = this.widen(l, want);
+                if (r !== undefined && kindOf(r) === "List")
+                    bodyOf(r).items = (bodyOf(r).items ?? []).map((x) => this.widen(x, element));
+                return null;
+            }
+            default: return null;
+        }
+        const comparison = ["=", "<>", "!=", "<", "<=", ">", ">="].includes(name);
+        // a citext beside a citext: compared lower-cased (citext_eq, citext_cmp); beside a text, Postgres's text operator
+        // compares the text as it is, and so does this
+        // (into l and r: what follows widens and pads THEM, and would put the column back)
+        if (comparison && this.isCitext(a0) && this.isCitext(a1) && l !== undefined && r !== undefined) {
+            l = b.lexpr = this.foldCitext(l);
+            r = b.rexpr = this.foldCitext(r);
+        }
+        if (comparison && name !== "=" && name !== "<>" && name !== "!=" && (a0 === INET || a1 === INET)) {
+            throw new Unrewritable(`comparing (${name}) inet values is not supported by Mason (Postgres orders addresses by network, then host)`, "compare them for equality, or compare host(x)::text", "inet-order");
+        }
+        // each operand as the type of the operator Postgres chose (`real / smallint` is float8's division, `real = 0.1`
+        // float8's comparison): DuckDB would compute in its own common type (single precision, for those)
+        if (l !== undefined)
+            b.lexpr = this.widen(l, a0);
+        if (r !== undefined)
+            b.rexpr = this.widen(r, l === undefined ? a0 : a1);
+        // char(n) beside char(n): compared without the padding (bpchareq, bpcharlt …)
+        if (a0 === BPCHAR && a1 === BPCHAR && ["=", "<>", "!=", "<", "<=", ">", ">="].includes(name) && l !== undefined && r !== undefined) {
+            b.lexpr = fn("rtrim", [l]);
+            b.rexpr = fn("rtrim", [r]);
+            this.typedLike.set(bodyOf(b.lexpr), l);
+            this.typedLike.set(bodyOf(b.rexpr), r);
+        }
+        if (comparison && b.lexpr !== undefined)
+            this.comparable(b.lexpr, `comparing (${name})`);
+        switch (name) {
+            case "/": {
+                if (l === undefined || r === undefined)
+                    return null;
+                if (a0 !== null && a1 !== null && INTEGERS.has(a0) && INTEGERS.has(a1))
+                    return op("//", b.lexpr, b.rexpr);
+                // a numeric quotient is Postgres's, rounded at its scale (numeric_div), so equal quotients are one value where
+                // DuckDB's double division gives each its own last bits; the client's text is the exact program's
+                if (a0 === NUMERIC && a1 === NUMERIC)
+                    return fn("__mason_numeric_div", [cast(b.lexpr, ["varchar"]), cast(b.rexpr, ["varchar"])]);
+                // a float division by zero is Postgres's error, where DuckDB answers Infinity or NULL
+                return op("/", b.lexpr, nonZero(this.cp, b.rexpr));
+            }
+            case "%": return null;
+            case "#": return a0 !== null && INTEGERS.has(a0) && l !== undefined && r !== undefined ? fn("xor", [b.lexpr, b.rexpr]) : null;
+            case "<<":
+            case ">>": {
+                // C's shift, as Postgres does it: the count masked to the word (31 for a smallint promoted to int, 63 for a
+                // bigint), a left shift wrapping to the type's width. DuckDB refuses to left-shift a negative number
+                if (a0 === null || !INTEGERS.has(a0) || l === undefined || r === undefined)
+                    return null;
+                const count = op("&", b.rexpr, intConst(a0 === INT8 ? 63 : 31));
+                const type = a0 === INT8 ? "bigint" : a0 === INT4 ? "integer" : "smallint";
+                if (name === ">>")
+                    return cast(op(">>", b.lexpr, count), [type]);
+                const bits = a0 === INT8 ? 64 : a0 === INT4 ? 32 : 16;
+                const huge = (v) => cast(strConst(String(v)), ["hugeint"]);
+                const product = op("*", cast(b.lexpr, ["hugeint"]), op("<<", huge(1n), count));
+                const half = huge(1n << BigInt(bits - 1)), whole = huge(1n << BigInt(bits));
+                return cast(op("-", op("%", op("+", op("%", op("+", product, half), whole), whole), whole), half), [type]);
+            }
+            case "*": {
+                // a numeric product is exact to 38 digits in Postgres; DuckDB multiplies two narrow DECIMALs in 18
+                if (t?.type !== NUMERIC || l === undefined || r === undefined)
+                    return null;
+                const wide = (x) => { const m = this.typed(x)?.typmod ?? -1; return m >= 4 && this.typeOf(x) === NUMERIC ? cast(x, ["decimal", "38", String((m - 4) & 0xffff)]) : x; };
+                b.lexpr = wide(b.lexpr);
+                b.rexpr = wide(b.rexpr);
+                return null;
+            }
+            case "-": {
+                if (a0 === JSONB && l !== undefined && r !== undefined) {
+                    if (a1 !== null && TEXTS.has(a1))
+                        return fn("__mason_jsonb_delete", [jsonArg(l), r]);
+                    throw new Unrewritable("jsonb - of a text array or an index is not supported by Mason", "build the value with jsonb_build_object", "jsonb-set");
+                }
+                // a date minus a date is Postgres's integer (date_mi), DuckDB's BIGINT: a date plus it has no DuckDB function
+                if (a0 === DATE && a1 === DATE && l !== undefined && r !== undefined)
+                    return cast(op("-", b.lexpr, b.rexpr), ["integer"]);
+                // a time minus a time: as timestamps of one day (DuckDB has no TIME - TIME)
+                if (a0 === TIME && a1 === TIME && l !== undefined && r !== undefined)
+                    return op("-", op("+", cast(strConst("2000-01-01"), ["date"]), l), op("+", cast(strConst("2000-01-01"), ["date"]), r));
+                return null;
+            }
+            case "#-": throw new Unrewritable("jsonb #- is not supported by Mason", "build the value with jsonb_build_object", "jsonb-set");
+            case "||": {
+                if (t?.type === JSONB && l !== undefined && r !== undefined)
+                    return fn("__mason_jsonb_concat", [jsonArg(l), jsonArg(r)]);
+                // text || a value (textanycat, anytextcat): the value's text is its output function's
+                // an array and an element or another array: DuckDB's || joins two of one type only
+                if (t !== null && ARRAYS.has(t.type) && l !== undefined && r !== undefined) {
+                    const la = a0 !== null && ARRAYS.has(a0), ra = a1 !== null && ARRAYS.has(a1);
+                    return la && ra ? caseWhen([[and([isNull(this.clone(l)), isNull(this.clone(r))]), nullConst()]], fn("list_concat", [l, r]))
+                        : la ? fn("list_append", [l, r]) : fn("list_prepend", [l, r]);
+                }
+                if (t === null || !TEXTS.has(t.type))
+                    return null;
+                // textanycat is `$1::text || $2`: the value's text is its cast's (`true`, where its output is `t`)
+                if (l !== undefined && a0 !== null && !TEXTS.has(a0))
+                    b.lexpr = this.pgText(l, a0, true) ?? l;
+                if (r !== undefined && a1 !== null && !TEXTS.has(a1))
+                    b.rexpr = this.pgText(r, a1, true) ?? r;
+                return null;
+            }
+            case "~":
+            case "~*":
+            case "!~":
+            case "!~*": {
+                if (l === undefined || r === undefined)
+                    return null;
+                const re = regexPattern(r);
+                // a pattern RE2 would read otherwise (regexPattern): Postgres's engine, a chunk at a time
+                if (re === null)
+                    return pgCall("bool", `a1 ${name} a2`, [l, r]);
+                const call = fn("regexp_matches", [l, re, ...(name.endsWith("*") ? [strConst("i")] : [])]);
+                return name.startsWith("!") ? not(call) : call;
+            }
+            case "#>":
+            case "#>>":
+            case "->":
+            case "->>": {
+                if (a0 === null || !JSONS.has(a0))
+                    return null;
+                const either = name.startsWith("#"), canonical = a0 === JSONB, asText = name.endsWith(">>");
+                let steps = either ? jsonPath(r) : jsonSteps([r], a1 !== null && INTEGERS.has(a1)), base = l;
+                // `(c -> 'a') ->> 'b'` is one read at the steps a, b (jsonChain)
+                const chain = this.jsonChain(l, either), literal = constString(steps);
+                if (chain !== null && literal !== null) {
+                    base = chain.base;
+                    steps = strConst(JSON.stringify([...chain.steps, ...JSON.parse(literal)]));
+                }
+                // a stored column of the path where every row holds it (keptRead), else DuckDB's own read where it is
+                // Postgres's, else the function (jsonGet)
+                return this.jsonRead(base, steps, either, canonical, asText);
+            }
+            case "@>":
+            case "<@":
+                if (a0 !== null && JSONS.has(a0))
+                    return name === "@>" ? fn("__mason_jsonb_contains", [jsonArg(l), jsonArg(r)]) : fn("__mason_jsonb_contains", [jsonArg(r), jsonArg(l)]);
+                if (a0 === null || ARRAY_DUCK[a0] === undefined && NUMBER_ELEMENT[a0] === undefined || l === undefined || r === undefined)
+                    return null;
+                {
+                    // an array's NULL element is contained in nothing in Postgres ('{NULL,3}' <@ '{1,2,3}' is false); DuckDB
+                    // finds it contained
+                    const inner = name === "@>" ? b.rexpr : b.lexpr;
+                    return { BoolExpr: { boolop: "AND_EXPR", args: [{ A_Expr: { ...b } }, op("=", fn("list_count", [this.cp(inner)]), fn("len", [this.cp(inner)]))] } };
+                }
+            case "?":
+            case "?|":
+            case "?&": {
+                if (a0 === null || !JSONS.has(a0))
+                    return null;
+                const f = { "?": "__mason_jsonb_exists", "?|": "__mason_jsonb_exists_any", "?&": "__mason_jsonb_exists_all" }[name];
+                return fn(f, [jsonArg(l), r]);
+            }
+            case "<":
+            case ">":
+            case "<=":
+            case ">=": {
+                if (l === undefined || r === undefined)
+                    return null;
+                // the operands as rewritten so far (a citext lower-cased to text sorts under the collation)
+                const c = this.textCollation(b.lexpr) ?? this.textCollation(b.rexpr);
+                if (c === null || c.kind === "bytes" || (t !== null && BYTE_COLLATIONS.has(t.inputCollation)))
+                    return null;
+                // the operands as Postgres cast them (a char(n) beside a text is its text without the padding)
+                return this.compareText(name, b.lexpr, b.rexpr, c);
+            }
+            default: return null;
+        }
+    }
+    widen(n, want) {
+        if (n === undefined || want === null || want === undefined || this.widened.get(bodyOf(n)) === want)
+            return n;
+        const made = this.widenOnce(n, want);
+        if (made !== n)
+            this.widened.set(bodyOf(made), want);
+        return made;
+    }
+    widenOnce(n, want) {
+        if ((want === TEXT || want === VARCHAR) && this.typeOf(n) === BPCHAR) {
+            const r = fn("rtrim", [n]);
+            this.typedLike.set(bodyOf(r), n);
+            return r;
+        }
+        // a date (or a timestamp) where Postgres chose a timestamptz's function, generate_series(date, date, interval)
+        // among them: cast in the session's zone, as Postgres's implicit cast is (DuckDB would keep a timestamp)
+        if (want === TIMESTAMPTZ || want === TIMESTAMP) {
+            const own = this.typeOf(n);
+            // a timestamptz Postgres chose is cast whatever the argument's own type reads as: an implicit cast of a constant
+            // has no offset of its own, so a date literal can read as the timestamptz it became
+            if (want === TIMESTAMPTZ)
+                return own === TIMESTAMPTZ && kindOf(n) !== "TypeCast" && kindOf(n) !== "A_Const" ? n : cast(n, ["timestamptz"]);
+            if (own === DATE)
+                return cast(n, ["timestamp"]);
+            return n;
+        }
+        if (want === NUMERIC || !NUMBER_TYPES.has(want))
+            return n;
+        const own = this.typeOf(n);
+        if (own === null || own === want || !NUMBER_TYPES.has(own))
+            return n;
+        const type = duckTypeOf(want);
+        return type === null ? n : cast(n, type);
+    }
+    /** a call kept as written: each argument as the type Postgres resolved it to (an ordered-set aggregate's sorted one) */
+    widenArgs(b) {
+        const t = this.typed({ FuncCall: b });
+        if (t === null)
+            return;
+        if (b.agg_within_group === true) {
+            for (const [i, s] of (b.agg_order ?? []).entries()) {
+                const sb = bodyOf(s);
+                if (isNode(sb.node))
+                    sb.node = this.widen(sb.node, t.args[i]?.type);
+            }
+            return;
+        }
+        if (Array.isArray(b.args))
+            b.args = b.args.map((a, i) => this.widen(a, t.args[i]?.type));
+    }
+    // --------------------------------------------------------------------------------------------- functions
+    funcCall(b) {
+        const name = lastName(b.funcname);
+        const t = this.typed({ FuncCall: b });
+        const args = (b.args ?? []);
+        const argType = (i) => t?.args[i]?.type ?? (args[i] !== undefined ? this.typeOf(args[i]) : null);
+        // each argument as the type Postgres resolved it to (a real to a double precision, a char(n) to its text), before
+        // any rule reads it; an aggregate's own ORDER BY of the same expression with it (DISTINCT needs them alike)
+        if (b.agg_within_group !== true) {
+            args.forEach((a, i) => {
+                const w = this.widen(a, t?.args[i]?.type);
+                if (w === a)
+                    return;
+                args[i] = w;
+                for (const s of (b.agg_order ?? []))
+                    if (isNode(bodyOf(s).node) && shapeOf(bodyOf(s).node) === shapeOf(a))
+                        bodyOf(s).node = this.widen(bodyOf(s).node, t?.args[i]?.type);
+            });
+        }
+        // an array of arrays is a multi-dimensional array, which DuckDB's lists are not
+        if ((name === "array_agg" || name === "array_cat") && args[0] !== undefined && argType(0) !== null && ARRAYS.has(argType(0)) && name === "array_agg") {
+            throw new Unrewritable("array_agg of an array (a multi-dimensional array) is not supported by Mason", "array_agg the elements, or array_to_string the arrays first", "multidim-array");
+        }
+        if ((name === "sum" || name === "avg") && argType(0) === INTERVAL)
+            throw new Unrewritable(`${name}() of an interval is not supported by Mason`, "sum(extract(epoch FROM x)) for the seconds", "interval-aggregates");
+        if (name === "sum" && this.typeOf(args[0] ?? { A_Const: {} }) === FLOAT4 && argType(0) === FLOAT4)
+            throw new Unrewritable("sum() of a real is not supported by Mason (Postgres adds in single precision)", "sum(x::double precision)", "sum-real");
+        if (b.agg_distinct === true && args[0] !== undefined)
+            this.comparable(args[0], `${name}(DISTINCT …) of`);
+        // a function-style cast (`date(x)`, `text(x)`, `numeric(x)`) is the cast
+        if (t !== null && (t.node === "COERCEVIAIO" || t.node === "RELABELTYPE" || (t.node === "FUNCEXPR" && t.format !== null && t.format !== 0 && t.format !== 3)) && args.length === 1) {
+            if (t.type === TEXT || t.type === VARCHAR) {
+                const text = this.pgText(args[0], this.typeOf(args[0]), true);
+                if (text !== null)
+                    return text;
+            }
+            const type = duckTypeOf(t.type, t.typmod);
+            if (type !== null && !(t.type === NUMERIC && t.typmod < 0))
+                return cast(args[0], type);
+        }
+        // an aggregate over DISTINCT values sorts them to find the duplicates, so Postgres's string_agg / array_agg (DISTINCT)
+        // lists them in that order (the argument's, under its collation); DuckDB's in any order
+        if (b.agg_distinct === true && b.agg_order === undefined && args[0] !== undefined && ["string_agg", "array_agg", "json_agg", "jsonb_agg"].includes(name)) {
+            b.agg_order = [{ SortBy: { node: this.clone(args[0]), sortby_dir: "SORTBY_DEFAULT", sortby_nulls: "SORTBY_NULLS_DEFAULT" } }];
+            this.original.add(bodyOf(b.agg_order[0]));
+        }
+        if (b.agg_within_group === true)
+            return this.withinGroup(name, b);
+        switch (name) {
+            case "every":
+                b.funcname = [S("bool_and")];
+                return null;
+            case "upper":
+            case "lower": {
+                if (args.length !== 1 || argType(0) === null || !TEXTS.has(argType(0)))
+                    return null;
+                // glibc's upper keeps ß (DuckDB's gives ẞ); its every other letter is DuckDB's (an exhaustive comparison over
+                // every code point differed only in letters newer than the server's glibc)
+                if (this.caseMode === "libc")
+                    return name === "lower" ? null : fn("replace", [fn("upper", [fn("replace", [args[0], strConst("ß"), strConst("\ufdd0")])]), strConst("\ufdd0"), strConst("ß")]);
+                return fn("__mason_case", [args[0], boolConst(name === "upper"), strConst(this.caseMode)]);
+            }
+            case "initcap": return args.length === 1 ? fn("__mason_initcap", [args[0], strConst(this.caseMode)]) : null;
+            case "btrim":
+                b.funcname = [S("trim")];
+                b.funcformat = "COERCE_EXPLICIT_CALL";
+                return null;
+            case "to_hex":
+                // an integer's two's complement in its own width, in lower case
+                if (args.length === 1 && argType(0) === INT4)
+                    return fn("lower", [fn("to_hex", [op("&", cast(args[0], ["bigint"]), numConst("4294967295"))])]);
+                return args.length === 1 ? fn("lower", [fn("to_hex", [args[0]])]) : null;
+            case "array_remove": {
+                // by the elements' text (src/duck/functions.ts), the answer cast back to the array's type
+                const element = ARRAY_DUCK[t?.type ?? -1];
+                if (element === undefined || args.length !== 2)
+                    throw new Unrewritable(`array_remove() of an array of type OID ${t?.type ?? "unknown"} is not supported by Mason`, "array_remove an array of text, integers, floats, booleans, dates or timestamps", "array-remove-type");
+                return arrayCast(fn("__mason_array_remove", [arrayCast(args[0], "varchar"), cast(args[1], ["varchar"])]), element);
+            }
+            case "overlaps": {
+                if (args.length !== 4)
+                    return null;
+                // (start, length) is the period start … start + length
+                const ends = args.map((a, i) => i % 2 === 1 && this.typeOf(a) === INTERVAL ? op("+", this.clone(args[i - 1]), a) : a);
+                const [a1, b1, a2, b2] = ends.map((a, i) => i % 2 === 0 || this.typeOf(args[i]) !== INTERVAL ? this.asInstant(a, t?.args[i]?.type ?? null) : a);
+                return overlaps(this.cp, a1, b1, a2, b2);
+            }
+            case "generate_series":
+                // in a SELECT list, a set of rows: DuckDB's generate_series there is one list, unnest makes it rows
+                if (this.inFrom.has(b))
+                    return null;
+                b.args = args.map((a, i) => i < 2 ? this.asInstant(a, argType(i)) : a);
+                return fn("unnest", [{ FuncCall: b }]);
+            case "regexp_match":
+            case "regexp_matches": return this.regexpMatch(name, b, args);
+            case "round":
+                if (args.length === 1 && argType(0) !== null && FLOATS.has(argType(0)))
+                    return fn("round_even", [args[0], intConst(0)]);
+                return null;
+            case "timezone":
+                // AT TIME ZONE z: the zone as Postgres reads it (zoneArg); the call kept
+                if (args.length === 2)
+                    b.args = [this.zoneArg(args[0]), args[1]];
+                return null;
+            case "date_trunc":
+                if (args.length === 3) {
+                    // in a zone: the wall clock there truncated, read back as an instant in that zone
+                    const [unit, ts] = args;
+                    const zone = this.zoneArg(args[2]);
+                    return fn("timezone", [zone, fn("date_trunc", [unit, fn("timezone", [this.clone(zone), this.asInstant(ts, argType(1))])])]);
+                }
+                if (args.length !== 2)
+                    return null;
+                {
+                    const unit = (constString(args[0]) ?? "").toLowerCase();
+                    const own = this.typeOf(args[1]);
+                    if (own === TIME)
+                        throw new Unrewritable("date_trunc() of a time is not supported by Mason", "date_trunc a timestamp, or extract the parts", "time-date-trunc");
+                    if (argType(1) === INTERVAL && unit === "week")
+                        throw new Unrewritable(`unit "week" not supported for type interval`, "", { postgres: "0A000" });
+                    const x = argType(1) === TIMESTAMPTZ && own === DATE ? cast(args[1], ["timestamptz"]) : args[1];
+                    // Postgres's centuries and millennia begin in a year 1 (2001-01-01), DuckDB's in a year 0 (DT_CENTURY)
+                    // (and a decade before year 1 is counted back as Postgres counts it: timestamp_trunc's DTK_DECADE)
+                    if ((unit === "century" || unit === "millennium" || unit === "decade") && argType(1) !== INTERVAL) {
+                        const y = fn("year", [this.clone(x)]);
+                        const first = unit === "decade"
+                            ? caseWhen([[op(">", y, intConst(0)), op("*", op("//", this.clone(y), intConst(10)), intConst(10))]], op("*", op("-", intConst(0), op("//", op("-", intConst(8), op("-", this.clone(y), intConst(1))), intConst(10))), intConst(10)))
+                            : (() => {
+                                const n = unit === "century" ? 100 : 1000;
+                                return caseWhen([[op(">", y, intConst(0)), op("-", op("*", op("//", op("+", this.clone(y), intConst(n - 1)), intConst(n)), intConst(n)), intConst(n - 1))]], op("+", op("*", op("-", intConst(0), op("//", op("-", intConst(n - 1), op("-", this.clone(y), intConst(1))), intConst(n))), intConst(n)), intConst(1)));
+                            })();
+                        const truncated = op("+", fn("date_trunc", [strConst("year"), this.clone(x)]), fn("to_years", [cast(op("-", first, this.clone(y)), ["integer"])]));
+                        return caseWhen([[fn("isfinite", [this.clone(x)]), truncated]], argType(1) === TIMESTAMPTZ ? cast(x, ["timestamptz"]) : cast(x, ["timestamp"]));
+                    }
+                    return x === args[1] ? null : fn("date_trunc", [args[0], x]);
+                }
+            case "make_interval": return makeInterval(args);
+            // isfinite of a time or an interval: DuckDB has none, and neither is ever infinite here
+            case "isfinite": {
+                const own = args[0] === undefined ? null : this.typeOf(args[0]);
+                return own === TIME || own === INTERVAL ? caseWhen([[isNull(args[0]), nullConst()]], boolConst(true)) : null;
+            }
+            case "date_bin": return args.length === 3 ? fn("time_bucket", args) : null;
+            case "justify_days":
+            case "justify_hours":
+            case "justify_interval": return args.length === 1 ? fn("__mason_justify", [strConst(name.slice("justify_".length)), args[0]]) : null;
+            case "rpad":
+            case "lpad":
+                if (args.length === 2)
+                    b.args = [...args, strConst(" ")];
+                return null;
+            case "chr":
+                if (args.length === 1)
+                    b.args = [cast(args[0], ["integer"])];
+                return null;
+            case "quote_literal": return args.length === 1 ? fn("__mason_quote_literal", [this.pgText(args[0], argType(0), true) ?? cast(args[0], ["varchar"])]) : null;
+            case "quote_ident": throw new Unrewritable("quote_ident() is not supported by Mason", "quote the identifier in the statement", "quote-ident");
+            case "length":
+            case "char_length":
+            case "character_length":
+                // a bytea's length is its bytes (DuckDB has no length of a BLOB)
+                if (args.length === 1 && argType(0) === BYTEA)
+                    return fn("octet_length", [args[0]]);
+                return args.length === 1 && argType(0) === BPCHAR ? fn("length", [fn("rtrim", [args[0]])]) : null;
+            // an empty array has no dimension 1 (Postgres's NULL; DuckDB has neither function)
+            case "array_upper":
+            case "array_lower": {
+                if (args.length !== 2)
+                    return null;
+                if (constInt(args[1]) !== 1)
+                    return constInt(args[1]) === null ? null : nullConst();
+                return caseWhen([[op(">", fn("len", [this.clone(args[0])]), intConst(0)), name === "array_upper" ? fn("len", [args[0]]) : intConst(1)]], null);
+            }
+            case "array_cat": return args.length === 2 ? caseWhen([[and([isNull(this.clone(args[0])), isNull(this.clone(args[1]))]), nullConst()]], fn("list_concat", args)) : null;
+            case "array_to_string": return args.length === 2 || args.length === 3 ? fn("__mason_array_to_string", [arrayCast(args[0], "varchar"), args[1], args[2] ?? cast(nullConst(), ["varchar"])]) : null;
+            case "jsonb_strip_nulls": return args.length === 1 ? fn("__mason_jsonb_strip_nulls", [jsonArg(args[0])]) : null;
+            case "jsonb_set":
+            case "jsonb_insert":
+            case "jsonb_set_lax": throw new Unrewritable(`${name}() is not supported by Mason`, "build the value with jsonb_build_object", "jsonb-set");
+            case "div": {
+                // div of two integers is their integer quotient, truncated toward zero
+                const own = args.map((a) => this.typeOf(a));
+                if (args.length === 2 && own.every((x) => x !== null && INTEGERS.has(x)))
+                    return cast(op("//", args[0], nonZero(this.cp, args[1])), ["decimal", "38", "0"]);
+                throw new Unrewritable("div() of a value that is not an integer is not supported by Mason", "trunc(a / b)", "div-numeric");
+            }
+            case "width_bucket": {
+                // width_bucket_float8 / _numeric: below the range 0, at or past its top count + 1, else the bucket
+                if (args.length !== 4 || (argType(0) !== FLOAT8 && argType(0) !== NUMERIC))
+                    throw new Unrewritable("width_bucket() of an array of thresholds is not supported by Mason", "width_bucket(value, low, high, count)", "width-bucket-forms");
+                const [x, lo, hi, n] = args.map((a) => argType(0) === FLOAT8 ? cast(a, ["double"]) : a);
+                const count = cast(args[3], ["integer"]);
+                const bucket = op("+", fn("least", [cast(fn("trunc", [op("*", n, op("/", op("-", x, lo), op("-", hi, this.clone(lo))))]), ["integer"]), op("-", this.clone(count), intConst(1))]), intConst(1));
+                return caseWhen([
+                    [or(args.map((a) => isNull(this.clone(a)))), nullConst()],
+                    [op(">=", this.clone(lo), this.clone(hi)), fn("error", [strConst(`mason: width_bucket() with its bounds reversed or equal is not supported by Mason (${"Mason gap width-bucket-forms"})`)])],
+                    [op("<", this.clone(x), this.clone(lo)), intConst(0)],
+                    [op(">=", this.clone(x), this.clone(hi)), op("+", this.clone(count), intConst(1))],
+                ], bucket);
+            }
+            case "extract": return this.extract(args);
+            case "date_part": return this.datePart(args);
+            case "jsonb_typeof":
+            case "json_typeof": return jsonTypeof(args[0]);
+            case "jsonb_array_length":
+            case "json_array_length": return args.length === 1 ? fn("__mason_json_array_length", [jsonArg(args[0])]) : null;
+            // DuckDB's string_split makes [''] of '' and characters of an empty delimiter (src/duck/functions.ts stringToArray)
+            case "string_to_array": return args.length === 2 || args.length === 3 ? fn("__mason_string_to_array", [args[0], args[1], args[2] ?? cast(nullConst(), ["varchar"])]) : null;
+            // an empty array has no dimension 1 (Postgres's NULL; DuckDB's 0)
+            case "array_length": {
+                if (args.length !== 2 || constInt(args[1]) !== 1)
+                    return null;
+                return caseWhen([[op("=", fn("len", [this.clone(args[0])]), intConst(0)), nullConst()]], fn("array_length", args));
+            }
+            // array_to_json(a) is to_json(a): one writer, so an array's elements are written by their type (a jsonb's embedded)
+            case "array_to_json":
+            case "jsonb_build_object":
+            case "json_build_object":
+            case "jsonb_build_array":
+            case "json_build_array":
+            case "to_json":
+            case "to_jsonb": {
+                if (name === "array_to_json" && args.length !== 1)
+                    return null;
+                const values = args.map((a, i) => this.jsonValue(a, t?.args[i]?.type ?? this.typeOf(a), name));
+                const style = name.endsWith("_object") ? "o" : name.endsWith("_array") ? "a" : "v";
+                return fn("__mason_json_build", [strConst(`${style}:${values.map((v) => v.kind).join("")}`), ...values.map((v) => v.value)]);
+            }
+            case "jsonb_agg":
+            case "json_agg": {
+                if (b.agg_distinct === true)
+                    throw new Unrewritable(`${name}(DISTINCT …) is not supported by Mason`, `select the DISTINCT values in a subquery and ${name} them`, "json-agg-distinct");
+                if (b.over !== undefined || args.length !== 1)
+                    return null;
+                const isArray = name === "json_agg" && argType(0) !== null && ARRAYS.has(argType(0));
+                const tested = isArray ? this.cp(args[0]) : null;
+                const v = this.jsonValue(args[0], argType(0), name);
+                const item = fn("__mason_json_value", [strConst(v.kind), v.value]);
+                // json_agg puts a line break before each array but the first, and never before a NULL (json_agg_transfn);
+                // jsonb_agg's text is canonical
+                if (tested !== null)
+                    return linedAgg(b, caseWhen([[isNull(tested), item]], concat(strConst("\n "), this.cp(item))), this.done);
+                const agg = { FuncCall: { ...b, funcname: [S("string_agg")], args: [item, strConst(", ")] } };
+                this.done.add(bodyOf(agg));
+                return concat(strConst("["), agg, strConst("]"));
+            }
+            case "jsonb_object_agg":
+            case "json_object_agg": {
+                if (b.over !== undefined || args.length !== 2 || b.agg_distinct === true)
+                    return null;
+                const v = this.jsonValue(args[1], argType(1), name);
+                const member = concat(fn("__mason_json_value", [strConst("s"), cast(args[0], ["varchar"])]), strConst(" : "), fn("__mason_json_value", [strConst(v.kind), v.value]));
+                const agg = { FuncCall: { ...b, funcname: [S("string_agg")], args: [member, strConst(", ")] } };
+                this.done.add(bodyOf(agg));
+                return concat(strConst("{ "), agg, strConst(" }"));
+            }
+            case "jsonb_extract_path_text":
+            case "json_extract_path_text":
+            case "jsonb_extract_path":
+            case "json_extract_path": {
+                const own = argType(0);
+                // VARIADIC <array>: the array's elements are the path (a literal as array_in reads it)
+                const literal = b.func_variadic === true && args.length === 2 ? constString(args[1]) : null;
+                const steps = b.func_variadic !== true ? jsonSteps(args.slice(1), false)
+                    : literal !== null ? strConst(JSON.stringify(arrayLiteral(literal)))
+                        : cast(fn("to_json", [arrayCast(args[1], "varchar")]), ["varchar"]);
+                const canonical = own === JSONB || name.startsWith("jsonb");
+                return this.jsonRead(args[0], steps, true, canonical, name.endsWith("_text"));
+            }
+            case "jsonb_object_keys":
+            case "json_object_keys":
+                if (this.inFrom.has(b))
+                    return null;
+                return fn("unnest", [fn("__mason_json_keys", [args[0], boolConst(name.startsWith("jsonb"))])]);
+            case "jsonb_array_elements":
+            case "json_array_elements":
+            case "jsonb_array_elements_text":
+            case "json_array_elements_text":
+            case "jsonb_each":
+            case "json_each":
+            case "jsonb_each_text":
+            case "json_each_text":
+                throw new Unrewritable(`${name}() in a SELECT list is not supported by Mason`, `read it in FROM: SELECT … FROM ${name}(…) AS e`, "json-rows-in-select");
+            case "regexp_replace": {
+                if (args.length < 3)
+                    return null;
+                const flags = constString(args[3]);
+                const re = regexPattern(args[1], true);
+                if (args.length > 4 || (args[3] !== undefined && (argType(3) === null || !TEXTS.has(argType(3))))) {
+                    throw new Unrewritable("regexp_replace() with a start position or a count is not supported by Mason", "write regexp_replace(text, pattern, replacement[, flags]); the flag g replaces every match", "regexp-flags");
+                }
+                // a pattern, a replacement or flags RE2 would read otherwise: Postgres's engine, a chunk at a time
+                if (re === null || constString(args[2]) === null || (args[3] !== undefined && (flags === null || !/^[gi]*$/.test(flags)))) {
+                    return pgCall("text", `regexp_replace(${args.map((_, i) => `a${i + 1}`).join(", ")})`, args);
+                }
+                b.args = [args[0], re, replacement(args[2]), ...args.slice(3)];
+                return null;
+            }
+            case "regexp_matches":
+            case "regexp_match":
+            case "regexp_split_to_table":
+            case "regexp_split_to_array":
+            case "regexp_count":
+            case "regexp_instr":
+            case "regexp_substr":
+            case "regexp_like":
+                throw new Unrewritable(`${name}() is not supported by Mason`, "test a match with ~ (or ~*), take a part with substring(text from pattern), or replace with regexp_replace", "regexp-functions");
+            case "substring":
+                // substring(text FROM pattern): Postgres's regular-expression form (two text arguments)
+                if (args.length === 2 && argType(1) !== null && TEXTS.has(argType(1))) {
+                    if (regexPattern(args[1], true) === null)
+                        return pgCall("text", "substring(a1 from a2)", args);
+                    return regexSubstring(this.cp, args[0], args[1]);
+                }
+                if (args.length === 3 && argType(1) !== null && TEXTS.has(argType(1)))
+                    throw new Unrewritable("substring(… SIMILAR … ESCAPE …) is not supported by Mason", "use substring(text from pattern) with a POSIX regular expression", "similar-to-forms");
+                return null;
+            case "octet_length":
+                if (argType(0) !== null && TEXTS.has(argType(0)))
+                    return fn("strlen", args);
+                return null;
+            case "to_char": return toChar(args, argType(0));
+            case "to_timestamp":
+                if (args.length === 2)
+                    return cast(fn("strptime", [args[0], strConst(strptimeFormat(args[1]))]), ["timestamptz"]);
+                return null;
+            case "to_date":
+                if (args.length === 2)
+                    return cast(fn("strptime", [args[0], strConst(strptimeFormat(args[1]))]), ["date"]);
+                return null;
+            case "format": return formatCall(args, (a, i) => this.pgText(a, argType(i), false) ?? cast(a, ["varchar"]));
+            // each value as its output function writes it (concat_ws's separator is text)
+            case "concat":
+            case "concat_ws":
+                b.args = args.map((a, i) => name === "concat_ws" && i === 0 ? a : this.pgText(a, argType(i), false) ?? a);
+                return null;
+            // an inet's text functions over its stored text (`10.3.6.45/32`)
+            case "host": return argType(0) === INET && args.length === 1 ? fn("regexp_replace", [args[0], strConst("/\\d+$"), strConst("")]) : null;
+            case "masklen": return argType(0) === INET && args.length === 1 ? cast(fn("regexp_extract", [args[0], strConst("/(\\d+)$"), intConst(1)]), ["integer"]) : null;
+            case "family": return argType(0) === INET && args.length === 1
+                ? caseWhen([[{ NullTest: { arg: this.cp(args[0]), nulltesttype: "IS_NULL" } }, nullConst()], [fn("contains", [args[0], strConst(":")]), intConst(6)]], intConst(4)) : null;
+            case "abbrev": return argType(0) === INET && args.length === 1 ? inetOut(args[0]) : null;
+            // the transaction's start, as of the execution (sqlValueFunction says why)
+            case "now":
+            case "transaction_timestamp": return args.length === 0 ? this.now("exec") : null;
+            case "age":
+                // age(t): from midnight of the session's day at the transaction's start (Postgres's `age(current_date, t)`),
+                // never DuckDB's own clock
+                if (args.length === 1 && (argType(0) === TIMESTAMP || argType(0) === TIMESTAMPTZ)) {
+                    b.args = [cast(cast(this.now("exec"), ["date"]), [argType(0) === TIMESTAMPTZ ? "timestamptz" : "timestamp"]), args[0]];
+                }
+                return null;
+            // jsonpath is Postgres's own language: each row's answer is Postgres's (src/duck/pg-eval.ts)
+            case "jsonb_path_query_array":
+            case "jsonb_path_query_first":
+            case "jsonb_path_exists":
+            case "jsonb_path_match": {
+                if (args.length < 2 || args.length > 4 || args.some((a) => kindOf(a) === "NamedArgExpr"))
+                    return null;
+                const call = pgCall(name.endsWith("_exists") || name.endsWith("_match") ? "bool" : "text", `${name}(${args.map((_, i) => `a${i + 1}::${JSONPATH_ARGS[i]}`).join(", ")})`, args);
+                return name.endsWith("_exists") || name.endsWith("_match") ? call : cast(call, ["json"]);
+            }
+            case "jsonb_path_query":
+                if (this.inFrom.has(b))
+                    return null;
+                throw new Unrewritable(`${name}() in a SELECT list is not supported by Mason`, `read it in FROM: SELECT … FROM ${name}(…) AS p`, "json-rows-in-select");
+            // a bytea's functions: DuckDB's octet_length, hex and md5 read a BLOB; Postgres's encodings are its own
+            case "encode": {
+                const format = constString(args[1]);
+                if (argType(0) !== BYTEA || args.length !== 2)
+                    return null;
+                if (format === "hex")
+                    return fn("lower", [fn("hex", [args[0]])]);
+                if (format === "base64" || format === "escape")
+                    return fn("__mason_bytea_encode", [fn("lower", [fn("hex", [args[0]])]), strConst(format)]);
+                throw new Unrewritable(`encode() to ${format === null ? "a format that is not a literal" : JSON.stringify(format)} is not supported by Mason`, "encode(x, 'hex'), 'base64' or 'escape'", "bytea-forms");
+            }
+            case "decode": {
+                const format = constString(args[1]);
+                if (args.length !== 2)
+                    return null;
+                if (format === "hex" || format === "base64" || format === "escape")
+                    return fn("unhex", [fn("__mason_bytea_decode", [cast(args[0], ["varchar"]), strConst(format)])]);
+                throw new Unrewritable(`decode() from ${format === null ? "a format that is not a literal" : JSON.stringify(format)} is not supported by Mason`, "decode(x, 'hex'), 'base64' or 'escape'", "bytea-forms");
+            }
+            case "convert_to":
+            case "convert_from": {
+                const encoding = (constString(args[1]) ?? "").toUpperCase().replace(/[-_]/g, "");
+                if (args.length !== 2 || encoding !== "UTF8")
+                    throw new Unrewritable(`${name}() of an encoding other than UTF8 is not supported by Mason`, `${name}(x, 'UTF8')`, "bytea-forms");
+                return fn(name === "convert_to" ? "encode" : "decode", [args[0]]);
+            }
+            case "min":
+            case "max": {
+                if (this.isCitext(argType(0)))
+                    throw new Unrewritable(`${name}() of a citext is not supported by Mason (Postgres picks it without regard to case)`, `${name}(x::text), or ${name}(lower(x))`, "citext-forms");
+                if (argType(0) === INET)
+                    throw new Unrewritable(`${name}() of an inet is not supported by Mason (Postgres orders addresses by network, then host)`, `${name}(host(x))`, "inet-order");
+                // a text array picks by each element under the collation: refused as its order is (text-array-order)
+                if (args[0] !== undefined)
+                    this.comparable(args[0], `${name}() of`);
+                return this.textMinMax(name, b, args);
+            }
+            default: return null;
+        }
+    }
+    /** a value Postgres reads as a timestamptz (a date or a timestamp is cast, as Postgres casts it implicitly) */
+    asInstant(n, wanted) {
+        const own = this.typeOf(n);
+        return wanted === TIMESTAMPTZ && own !== null && own !== TIMESTAMPTZ && own !== UNKNOWN ? cast(n, ["timestamptz"]) : n;
+    }
+    textMinMax(name, b, args) {
+        const arg = args[0];
+        // a window's too (`max(t) OVER (…)`): arg_min / arg_max are DuckDB window aggregates as well
+        if (arg === undefined)
+            return null;
+        const c = this.textCollation(arg);
+        if (c === null || c.kind === "bytes")
+            return null;
+        if (c.kind === "icu") {
+            b.args = [collate(strip(arg), c.name)];
+            return null;
+        }
+        // libc: the value whose key is least (or greatest); a NULL value has no key and is skipped, as min skips it
+        // (the value in three places, each its own copy: the walker rewrites a node in its first place alone)
+        const key = caseWhen([[not(isNull(this.cp(strip(arg)))), row(libcKeys(this.cp, this.cp(strip(arg)), c.icu))]], null);
+        return { FuncCall: { ...b, funcname: [S(name === "min" ? "arg_min" : "arg_max")], args: [strip(arg), key] } };
+    }
+    /** WITHIN GROUP: mode() picks the most frequent value and, of equals, the first in the ORDER BY's order — DuckDB's
+     *  mode over the values in that order picks the same (its tie goes to the first it saw); percentile_disc / _cont
+     *  take a position in the order, which DuckDB computes by bytes: refused for text under a libc collation */
+    withinGroup(name, b) {
+        const order = (b.agg_order ?? []);
+        const key = order[0] !== undefined ? bodyOf(order[0]).node : undefined;
+        const c = key === undefined ? null : this.textCollation(key);
+        if (c === null || c.kind === "bytes")
+            return null;
+        if (name === "mode" && order.length === 1) {
+            return { FuncCall: { ...b, args: [this.clone(key)], agg_within_group: undefined } };
+        }
+        if (c.kind === "libc")
+            throw new Unrewritable(`${name}() WITHIN GROUP (ORDER BY text) under the database's libc collation is not supported by Mason`, "order by a number, or take the value with ORDER BY … LIMIT in a subquery", "percentile-text-libc");
+        return null;
+    }
+    /** regexp_match: the first match's groups (or the match) as an array, NULL without one; regexp_matches: a row per
+     *  match ('g') or for the first, each such an array */
+    regexpMatch(name, b, args) {
+        const pattern = constString(args[1]);
+        const flags = args[2] === undefined ? "" : constString(args[2]);
+        // a pattern or flags RE2 would read otherwise: Postgres's engine, a chunk at a time (regexp_matches's rows, each
+        // match's text[], as JSON)
+        const viaPostgres = () => {
+            const call = `${name}(${args.map((_, i) => `a${i + 1}`).join(", ")})`;
+            if (name === "regexp_match")
+                return pgCall("list", call, args);
+            const rows = pgCall("list", `ARRAY(SELECT to_json(mason_m)::text FROM ${call} AS mason_m)`, args);
+            const matrix = { TypeCast: { arg: arrayCast(rows, "json"), typeName: { names: [S("varchar")], typemod: -1, arrayBounds: [{ Integer: { ival: -1 } }, { Integer: { ival: -1 } }] } } };
+            return fn("unnest", [matrix]);
+        };
+        if (name === "regexp_matches" && this.inFrom.has(b))
+            throw new Unrewritable("regexp_matches() in FROM is not supported by Mason", "call it in the SELECT list: SELECT regexp_matches(…) FROM t", "regexp-matches-forms");
+        if (pattern === null || flags === null || regexPattern(args[1], true) === null || !/^[gi]*$/.test(flags)
+            || (name === "regexp_matches" && flags.includes("g") && captureGroups(pattern) > 1))
+            return viaPostgres();
+        if (name === "regexp_match" && flags.includes("g"))
+            throw new Unrewritable("regexp_match() does not support the \"global\" option", "use the regexp_matches function instead", { postgres: "22023" });
+        const s = args[0];
+        const re = regexPattern(args[1], true);
+        const options = strConst(flags.includes("i") ? "i" : "");
+        const groups = captureGroups(pattern);
+        const extract = (g) => fn("regexp_extract", [this.clone(s), this.clone(re), intConst(g), this.clone(options)]);
+        const found = arrayOf(groups === 0 ? [extract(0)] : Array.from({ length: groups }, (_, i) => extract(i + 1)));
+        const matches = fn("regexp_matches", [s, re, options]);
+        if (name === "regexp_match")
+            return caseWhen([[matches, found]], null);
+        if (!flags.includes("g"))
+            return fn("unnest", [caseWhen([[matches, arrayOf([found])]], null)]);
+        // each match's group as a one-element array: list_value of the unnested matches
+        return fn("list_value", [fn("unnest", [fn("regexp_extract_all", [this.clone(s), this.clone(re), intConst(groups === 0 ? 0 : 1), this.clone(options)])])]);
+    }
+    /**
+     * A value's TEXT as Postgres writes it where DuckDB's cast to VARCHAR writes another — its output function's (what
+     * `concat`, `format`, `||` and to_json write) or, `asCast`, an explicit cast's (which differs from the output for a
+     * boolean alone: `true::text` is `true`, its output `t`). Null where DuckDB's VARCHAR is already Postgres's text.
+     */
+    pgText(n, type, asCast) {
+        if (type === null)
+            return null;
+        // a char(n)'s output is padded; its cast to text drops the padding
+        if (type === BPCHAR)
+            return asCast ? fn("rtrim", [n]) : null;
+        // a float cast to numeric is a DuckDB double; Postgres's numeric holds the float's shortest digits, written plainly
+        // (`round(x)::numeric::text` is `25`, never `25.0`; `1e-7` is `0.0000001`)
+        if (type === NUMERIC && kindOf(n) === "TypeCast" && (this.typed(n)?.typmod ?? -1) < 0) {
+            const inner = bodyOf(n).arg, from = this.typeOf(inner);
+            if (from !== null && FLOATS.has(from))
+                return fn("__mason_float_numeric_text", [cast(inner, ["double"]), boolConst(from === FLOAT4)]);
+        }
+        // an inet's output drops a full mask (`10.3.6.45`, `::1`); its cast to text keeps it (`10.3.6.45/32`), as stored
+        if (type === INET)
+            return asCast ? null : inetOut(n);
+        // a bytea's text is its hex (bytea_output = hex): `\x00ff`
+        if (type === BYTEA)
+            return concat(strConst("\\x"), fn("lower", [fn("hex", [n])]));
+        if (FLOATS.has(type))
+            return fn("__mason_float_text", [cast(n, ["double"]), boolConst(type === FLOAT4)]);
+        if (type === BOOL)
+            return asCast ? null : caseWhen([[n, strConst("t")], [not(this.clone(n)), strConst("f")]], null);
+        if (type === INTERVAL)
+            return fn("__mason_interval_text", [n]);
+        if (ARRAYS.has(type))
+            return fn("__mason_array_text", [arrayCast(n, "varchar"), boolConst(type === 1000)]);
+        if (type === JSONB)
+            return fn("__mason_jsonb_text", [n]);
+        // a year before 1 is DuckDB's `4713-11-24 (BC)`, Postgres's `4713-11-24 BC` (after the time, for a timestamp)
+        if (type === DATE || type === TIMESTAMP || type === TIMESTAMPTZ)
+            return fn("regexp_replace", [cast(n, ["varchar"]), strConst("^(\\S+) \\(BC\\)(.*)$"), strConst("\\1\\2 BC")]);
+        return null;
+    }
+    /** a value as json_build_object / json_agg / to_json write it: its text, and how (by its Postgres type) */
+    jsonValue(n, oid, fnName) {
+        // an array: each element written as its own type's json (src/duck/functions.ts jsonArray), from its text as DuckDB
+        // writes it — only for elements whose text is Postgres's (not a float's NaN, a timestamp's T, an interval's or a
+        // char(n)'s). Never DuckDB's to_json of the list: it quotes a jsonb element's text as a string (`["\"x\""]`)
+        const element = oid === null ? undefined : JSON_ARRAY_ELEMENT[oid];
+        if (element !== undefined)
+            return { kind: "r", value: fn("__mason_json_array", [strConst(element), arrayCast(n, "varchar")]) };
+        if (oid === JSONB)
+            return { kind: "k", value: cast(n, ["varchar"]) };
+        if (oid === TIMESTAMPTZ)
+            return { kind: "z", value: this.pgText(n, oid, false) ?? cast(n, ["varchar"]) };
+        if (oid === TIMESTAMP)
+            return { kind: "t", value: this.pgText(n, oid, false) ?? cast(n, ["varchar"]) };
+        if (oid !== null && (FLOATS.has(oid) || oid === NUMERIC))
+            return { kind: "n", value: this.pgText(n, oid, false) ?? cast(n, ["varchar"]) };
+        if (oid !== null && (INTEGERS.has(oid) || oid === BOOL || oid === JSON_OID))
+            return { kind: "r", value: cast(n, ["varchar"]) };
+        if (oid !== null && (TEXTS.has(oid) || oid === UUID || oid === DATE || oid === TIME || oid === INTERVAL || oid === INET))
+            return { kind: "s", value: this.pgText(n, oid, false) ?? cast(n, ["varchar"]) };
+        throw new Unrewritable(`${fnName}() of a value of type OID ${oid ?? "unknown"} is not supported by Mason`, "cast the value to text, a number, a boolean, a timestamp or json first", "json-of-type");
+    }
+    /** EXTRACT, as the exact numeric Postgres returns: `epoch` and `second` with their fraction, the rest whole */
+    extract(args) {
+        const field = (constString(args[0]) ?? "").toLowerCase();
+        const x = args[1];
+        const type = this.typeOf(x);
+        this.unitSupported(field, type);
+        // an interval's parts as Postgres computes them (src/duck/functions.ts intervalPart)
+        if (type === INTERVAL)
+            return cast(fn("__mason_interval_part", [strConst(field), x]), ["decimal", "38", INTERVAL_SCALE[field] ?? "0"]);
+        // a field that grows with time is ±Infinity of an infinite time, which a DECIMAL cannot hold: refused when met
+        if ((type === DATE || type === TIMESTAMP || type === TIMESTAMPTZ) && MONOTONIC.has(field)) {
+            const inner = this.extractFinite(field, this.clone(x), type) ?? fn("date_part", [strConst(field), this.clone(x)]);
+            // tested as NOT isfinite: isfinite of a NULL is NULL, which would take the infinite branch
+            return caseWhen([[not(fn("isfinite", [x])), fn("error", [strConst(`mason: extract(${field} …) of an infinite date or timestamp is not supported by Mason (Mason gap infinite-extract)`)])]], inner);
+        }
+        return this.extractFinite(field, x, type);
+    }
+    /** Postgres refuses a unit a type does not have (at run time, so its analysis does not): its words, its SQLSTATE */
+    unitSupported(field, type) {
+        const name = type === DATE ? "date" : type === TIMESTAMP ? "timestamp without time zone" : type === TIME ? "time without time zone" : null;
+        const refused = type === DATE ? ["hour", "minute", "second", "milliseconds", "microseconds", "timezone", "timezone_hour", "timezone_minute", "timezone_m"]
+            : type === TIMESTAMP || type === TIME ? ["timezone", "timezone_hour", "timezone_minute"] : [];
+        if (name !== null && refused.includes(field))
+            throw new Unrewritable(`unit "${field}" not supported for type ${name}`, "", { postgres: "0A000" });
+    }
+    extractFinite(field, x, type) {
+        const micros = (expr, scale) => op("*", cast(expr, ["decimal", "38", "0"]), numConst(scale));
+        switch (field) {
+            case "epoch":
+                return type === DATE ? cast(fn("epoch", [x]), ["decimal", "38", "0"]) : micros(fn("epoch_us", [x]), "0.000001");
+            case "second": return micros(fn("microsecond", [x]), "0.000001");
+            case "milliseconds": return micros(fn("microsecond", [x]), "0.001");
+            case "microseconds": return cast(fn("microsecond", [x]), ["decimal", "38", "0"]);
+            case "julian": throw new Unrewritable("extract(julian …) is not supported by Mason", "compute it from extract(epoch …) / 86400 + 2440587.5", "extract-julian");
+            default: return null;
+        }
+    }
+    /** date_part: Postgres's double precision, a second with its fraction; ±Infinity of an infinite time */
+    datePart(args) {
+        const field = (constString(args[0]) ?? "").toLowerCase();
+        const x = args[1];
+        const type = this.typeOf(x);
+        this.unitSupported(field, type);
+        if (type === INTERVAL)
+            return cast(fn("__mason_interval_part", [strConst(field), x]), ["double"]);
+        if ((type === DATE || type === TIMESTAMP || type === TIMESTAMPTZ) && MONOTONIC.has(field)) {
+            const inner = this.datePartFinite(field, this.clone(x)) ?? fn("date_part", [strConst(field), this.clone(x)]);
+            // tested as NOT isfinite: isfinite of a NULL is NULL, which would take an infinite branch
+            const infinite = () => not(fn("isfinite", [this.clone(x)]));
+            return caseWhen([[and([infinite(), op(">", this.clone(x), cast(strConst("2000-01-01"), ["date"]))]), cast(strConst("Infinity"), ["double"])],
+                [infinite(), cast(strConst("-Infinity"), ["double"])]], inner);
+        }
+        return this.datePartFinite(field, x);
+    }
+    datePartFinite(field, x) {
+        switch (field) {
+            case "second": return op("/", cast(fn("microsecond", [x]), ["double"]), numConst("1000000.0"));
+            case "milliseconds": return op("/", cast(fn("microsecond", [x]), ["double"]), numConst("1000.0"));
+            case "epoch": return this.typeOf(x) === DATE ? cast(fn("epoch", [x]), ["double"]) : op("/", cast(fn("epoch_us", [x]), ["double"]), numConst("1000000.0"));
+            default: return null;
+        }
+    }
+    // --------------------------------------------------------------------------------------------- casts, constants
+    /** a timestamp (or timestamptz) rounded to `p` decimals of a second: half away from 2000-01-01, an infinity kept */
+    roundTime(x, p) {
+        const unit = intConst(10 ** (6 - p));
+        const e = () => op("-", fn("epoch_us", [this.cp(x)]), numConst("946684800000000"));
+        const rounded = op("*", op("*", fn("sign", [e()]), op("//", op("+", fn("abs", [e()]), intConst(10 ** (6 - p) / 2)), unit)), this.cp(unit));
+        return caseWhen([[fn("isfinite", [this.cp(x)]), op("+", this.cp(x), fn("to_microseconds", [op("-", rounded, e())]))]], x);
+    }
+    /** a text read as `type` (with `typmod`) by Postgres's own input function, a chunk at a time (`__mason_pg_*`,
+     *  src/duck/functions.ts), under the zone DuckDB's session has; null for a type DuckDB reads as Postgres does */
+    pgInput(arg, type, typmod) {
+        const p = typmod >= 4 ? (typmod - 4) >> 16 : -1, sc = typmod >= 4 ? (typmod - 4) & 0xffff : -1;
+        const spelled = {
+            [DATE]: ["date", "date", null], [TIMESTAMP]: [typmod >= 0 ? `timestamp(${typmod})` : "timestamp", "timestamp", null],
+            [TIMESTAMPTZ]: [typmod >= 0 ? `timestamptz(${typmod})` : "timestamptz", "timestamptz", null], [INTERVAL]: ["interval", "interval", null],
+            [BOOL]: ["boolean", "bool", null], [UUID]: ["uuid", "text", ["uuid"]], [INT2]: ["smallint", "int8", ["smallint"]], [INT4]: ["integer", "int8", ["integer"]], [INT8]: ["bigint", "int8", null],
+            // a numeric is its digits beside it (exactOf); here the value DuckDB computes with
+            [NUMERIC]: [p >= 0 ? `numeric(${p},${sc})` : "numeric", "text", p >= 0 && p <= 38 ? ["decimal", String(p), String(sc)] : ["double"]],
+        };
+        const s = spelled[type];
+        if (s === undefined)
+            return null;
+        const call = pgCall(s[1], `a1::${s[0]}`, [arg]);
+        return s[2] === null ? call : cast(call, s[2]);
+    }
+    typeCast(b) {
+        const target = lastName(b.typeName?.names);
+        const t = this.typed({ TypeCast: b });
+        const arg = b.arg;
+        // a GROUP BY or ORDER BY repeating `INTERVAL '1 day'` of the SELECT list: its literal has no analysed node of its
+        // own (Postgres refers to the list's), and is the value the list's was parsed to — the same SQL on both sides
+        if (t?.node === "CONST" && kindOf(arg) === "A_Const" && this.at(bodyOf(arg), ["CONST"]) === null)
+            this.constLike.set(bodyOf(arg), t);
+        const from = this.typeOf(arg);
+        // to an enum (or an array of one): a label, a text read by Postgres's rules, or the enum it already is
+        if (t !== null && (this.enums.labels.has(t.type) || this.enums.arrays.has(t.type))) {
+            if (from === t.type)
+                return arg;
+            if (constString(arg) !== null)
+                return this.enumValue(arg, t.type, constString(arg));
+            if (from !== null && TEXTS.has(from))
+                return this.enumValue(arg, t.type, null);
+        }
+        const isArray = Array.isArray(b.typeName?.arrayBounds) && b.typeName.arrayBounds.length > 0;
+        if (isArray) {
+            // an array literal ('{a,b}'::text[]): its elements, read as array_in reads them
+            const literal = constString(arg);
+            const element = ARRAY_ELEMENT[target];
+            if (literal === null || element === undefined)
+                return null;
+            const list = arrayOf(arrayLiteral(literal).map((e) => e === null ? nullConst() : strConst(e)));
+            return element === "varchar" ? list : arrayCast(list, element);
+        }
+        // a text read as a date, a time, an interval, a boolean, an integer or a numeric: by Postgres's own input function
+        // (src/duck/pg-eval.ts), which reads `01/02/2026`, `1 day ago`, ` yes `, `0x1F` and `1_000` (DuckDB reads ISO alone)
+        if (t !== null && from !== null && TEXTS.has(from) && from !== UNKNOWN && constString(arg) === null) {
+            const read = this.pgInput(arg, t.type, t.typmod);
+            if (read !== null) {
+                this.typedLike.set(bodyOf(read), { TypeCast: b });
+                if (target === "interval" && Array.isArray(b.typeName?.typmods) && b.typeName.typmods.length > 0)
+                    return intervalFields(read, constInt(b.typeName.typmods[0]));
+                return read;
+            }
+        }
+        // a value's text is Postgres's (an array's `{a,b}`, a jsonb's canonical text, a float's shortest digits …), cut to a
+        // varchar(n)'s length as the explicit cast cuts it
+        // to char(n): the text cut and padded to n
+        if (t !== null && t.type === BPCHAR && t.typmod > 4) {
+            const text = from === BPCHAR ? arg : this.pgText(arg, from, true) ?? cast(arg, ["varchar"]);
+            return fn("rpad", [fn("left", [text, intConst(t.typmod - 4)]), intConst(t.typmod - 4), strConst(" ")]);
+        }
+        if (t !== null && (t.type === TEXT || t.type === VARCHAR)) {
+            const text = this.pgText(arg, from, true);
+            if (text !== null)
+                return t.type === VARCHAR && t.typmod > 4 ? fn("left", [text, intConst(t.typmod - 4)]) : text;
+        }
+        // timestamp(p) / timestamptz(p) of a time: rounded to p decimals of a second as AdjustTimestampForTypmod rounds, half
+        // away from Postgres's epoch (2000-01-01: `1960-01-01 00:00:00.5` is `00:00:00`); DuckDB rounds otherwise or not at all
+        if (t !== null && (t.type === TIMESTAMP || t.type === TIMESTAMPTZ) && kindOf(arg) !== "A_Const" && from !== null && (from === DATE || from === TIMESTAMP || from === TIMESTAMPTZ)) {
+            const own = from === t.type ? arg : cast(arg, [t.type === TIMESTAMPTZ ? "timestamptz" : "timestamp"]);
+            return t.typmod >= 0 && t.typmod < 6 ? this.roundTime(own, t.typmod) : own;
+        }
+        if (target === "name")
+            return fn("left", [this.pgText(arg, from, true) ?? cast(arg, ["varchar"]), intConst(63)]);
+        if (target === "time" && from === TIMESTAMPTZ)
+            return cast(cast(arg, ["timestamp"]), ["time"]);
+        if (target === "interval" && Array.isArray(b.typeName?.typmods) && b.typeName.typmods.length > 0)
+            return intervalFields(arg, constInt(b.typeName.typmods[0]));
+        // a text or a json read as jsonb is jsonb's canonical text (keys sorted and once, `1.0` kept, whitespace Postgres's),
+        // as the copy stores a jsonb column
+        if (target === "jsonb" && from !== JSONB && from !== null && (TEXTS.has(from) || from === JSON_OID))
+            return cast(fn("__mason_jsonb_text", [cast(arg, ["varchar"])]), ["json"]);
+        if (target === "jsonb" || target === "json") {
+            b.typeName = { names: [S("json")], typemod: -1 };
+            return null;
+        }
+        if (target === "numeric" || target === "decimal") {
+            const typmods = (b.typeName?.typmods ?? []);
+            if (typmods.length > 0) {
+                const p = constInt(typmods[0]), s = typmods.length > 1 ? constInt(typmods[1]) : 0;
+                if (p !== null && p > 38)
+                    return cast(arg, ["double"]);
+                if (p !== null)
+                    return cast(arg, ["decimal", String(p), String(s ?? 0)]);
+                return null;
+            }
+            // an unconstrained numeric keeps the value's digits: an integer is a whole decimal, a literal text is read as a
+            // decimal literal (BEFORE a numeric: Postgres types `'1.5'` as the cast's numeric, and as it stood DuckDB answered
+            // the text, `2.5e2` for 250), a numeric stays what it is
+            if (from !== null && INTEGERS.has(from))
+                return cast(arg, ["decimal", "38", "0"]);
+            // as numeric_in reads it (`1_000`, `0x1F`, `1.5e3`: one reader, src/lib/pg-numeric.ts); NaN and Infinity are no
+            // DuckDB decimal and keep the double below
+            const s = constString(arg);
+            const literal = s === null ? null : numericLiteral(s);
+            if (literal !== null)
+                return decimalConst(literal);
+            if (from === NUMERIC)
+                return arg;
+            return cast(arg, ["double"]);
+        }
+        if ((target === "varchar" || target === "bpchar") && t !== null && t.typmod > 4 && target === "varchar") {
+            // varchar(n) cuts the value to n characters, as Postgres's explicit cast does
+            return fn("left", [cast(arg, ["varchar"]), intConst(t.typmod - 4)]);
+        }
+        return null;
+    }
+    aConst(b) {
+        // a string Postgres read as an array ('{1}' beside an int[]): its elements, as array_in reads them
+        if (b.sval !== undefined) {
+            const t = this.at(b, ["CONST"]) ?? this.constLike.get(b) ?? null;
+            // a label of an enum (or an array of them) Postgres read it as: DuckDB's ENUM, which compares by the declared order
+            // where the text would compare as text
+            const asEnum = t === null ? null : this.enumValue(strConst(String(b.sval.sval ?? "")), t.type, String(b.sval.sval ?? ""));
+            if (asEnum !== null)
+                return asEnum;
+            // a date, timestamp or interval: the value Postgres parsed, never the text again — DuckDB reads only ISO, and not
+            // `'01/02/2026'`, `'March 1, 2026'`, `'… BC'`, `'epoch'`, `'1 day ago'` or `'P1D'`
+            // an inet literal as Postgres canonicalises it (`'10.3.6.45'` is `10.3.6.45/32`, as the copy stores the column)
+            // a bytea literal (`'\x00ff'`, an escaped `'a\000b'`): the bytes Postgres read, by their hex
+            if (t !== null && t.type === BYTEA && t.datum !== null && t.datum.length >= 4)
+                return fn("unhex", [strConst(t.datum.slice(4).map((x) => x.toString(16).padStart(2, "0")).join(""))]);
+            if (t !== null && t.type === INET && t.datum !== null) {
+                const text = datumText(INET, t.datum);
+                if (text !== null)
+                    return strConst(text);
+            }
+            if (t !== null && t.type === INTERVAL && t.datum !== null) {
+                const parts = intervalDatum(t.datum);
+                if (parts !== null)
+                    return cast(strConst(`${parts.months} months ${parts.days} days ${parts.micros} microseconds`), ["interval"]);
+            }
+            if (t !== null && (t.type === DATE || t.type === TIMESTAMP || t.type === TIMESTAMPTZ)) {
+                const text = String(b.sval.sval ?? "");
+                const word = /^\s*(now|today|tomorrow|yesterday)\s*$/i.exec(text)?.[1]?.toLowerCase();
+                if (word !== undefined)
+                    return this.relativeTime(word, t.type);
+                if (/\b(now|today|tomorrow|yesterday)\b/i.test(text)) {
+                    throw new Unrewritable(`the literal '${text}' is not supported by Mason: it means another time on each run`, "write current_date, now(), current_date + 1 or current_date - 1", "relative-time-literal");
+                }
+                const iso = t.datum === null ? null : datumText(t.type, t.datum);
+                if (iso !== null)
+                    return cast(strConst(iso), [t.type === DATE ? "date" : t.type === TIMESTAMP ? "timestamp" : "timestamptz"]);
+            }
+            const element = t === null ? undefined : ARRAY_DUCK[t.type];
+            if (element !== undefined) {
+                const list = arrayOf(arrayLiteral(String(b.sval.sval ?? "")).map((e) => e === null ? nullConst() : strConst(e)));
+                return element === "varchar" ? list : arrayCast(list, element);
+            }
+        }
+        // a NULL of an enum type (`null::mood`): DuckDB's ENUM, which enum_first and enum_range need
+        if (b.isnull === true) {
+            const t = this.at(b, ["CONST"]) ?? this.constLike.get(b) ?? null;
+            const labels = t === null ? undefined : this.enums.labels.get(t.type);
+            if (labels !== undefined)
+                return enumCast(nullConst(), labels);
+        }
+        // a numeric literal with an exponent is a positional decimal (DuckDB reads `1e-7` as a double)
+        if (b.fval !== undefined && /[eE]/.test(String(b.fval.fval ?? ""))) {
+            const t = this.at(b, ["CONST"]);
+            if (t === null || t.type === NUMERIC)
+                return decimalConst(positional(String(b.fval.fval)));
+        }
+        return null;
+    }
+    /** a value of an enum type (or an enum array type), as DuckDB's ENUM: a constant label, or one read by Postgres's rules
+     *  from a text (`__mason_enum_in`: 22P02 for a label the type lacks); null for any other type */
+    enumValue(text, type, literal) {
+        const own = this.enums.labels.get(type);
+        if (own !== undefined)
+            return enumCast(literal !== null ? strConst(literal) : fn("__mason_enum_in", [cast(text, ["varchar"]), strConst(this.userTypes.get(type) ?? "enum"), arrayOf(own.map(strConst))]), own);
+        const element = this.enums.arrays.get(type);
+        const labels = element === undefined ? undefined : this.enums.labels.get(element);
+        if (labels === undefined)
+            return null;
+        if (literal === null)
+            throw new Unrewritable("an array of an enum read from a text is not supported by Mason", "write the array as a literal, or ARRAY[…] of its labels", "enum-forms");
+        const elements = arrayLiteral(literal);
+        if (elements.some((e) => e !== null && !labels.includes(e)))
+            return null;
+        return enumCast(arrayOf(elements.map((e) => e === null ? nullConst() : strConst(e))), labels, true);
+    }
+    param(b) {
+        // a parameter is bound as its text; Postgres decided its type, and DuckDB is told it
+        const oid = this.params[Number(b.number) - 1];
+        const asEnum = oid === undefined || !this.enums.labels.has(oid) ? null : this.enumValue({ ParamRef: b }, oid, null);
+        if (asEnum !== null)
+            return asEnum;
+        const type = oid === undefined ? null : oid === NUMERIC ? ["double"] : duckTypeOf(oid);
+        return type === null ? null : cast({ ParamRef: b }, type);
+    }
+    /**
+     * The reads a json read is made off (`(c -> 'a') -> 0`, `c #> '{a}'`), folded into one read's steps: the inner
+     * read's text parsed again is the same tree (jsonb's canonical text is canonical; json's is the document's own
+     * slice), so stepping on from it is stepping on in place — one parse instead of one per operator, and the native
+     * read (jsonGet) sees the column. Reads of one operator family only (`->`'s steps are keys and indexes, `#>`'s
+     * elements are either), with literal keys; null for anything else, which is read as written.
+     */
+    jsonChain(node, either) {
+        if (kindOf(node) !== "A_Expr")
+            return null;
+        const b = bodyOf(node);
+        if (b.kind !== "AEXPR_OP" || lastName(b.name) !== (either ? "#>" : "->") || b.lexpr === undefined || b.rexpr === undefined)
+            return null;
+        const t = this.typed(node);
+        const a0 = t?.args[0]?.type ?? null, a1 = t?.args[1]?.type ?? null;
+        if (a0 === null || !JSONS.has(a0))
+            return null;
+        const r = b.rexpr;
+        const own = constString(either ? jsonPath(r) : jsonSteps([r], a1 !== null && INTEGERS.has(a1)));
+        if (own === null)
+            return null;
+        const deeper = this.jsonChain(b.lexpr, either);
+        return { base: deeper === null ? b.lexpr : deeper.base, steps: [...(deeper === null ? [] : deeper.steps), ...JSON.parse(own)] };
+    }
+    // --------------------------------------------------------------------------------------------- FROM
+    rangeFunction(b) {
+        const items = (b.functions ?? []);
+        const first = items[0] !== undefined ? bodyOf(items[0]).items?.[0] : undefined;
+        if (first === undefined || kindOf(first) !== "FuncCall")
+            return null;
+        const call = bodyOf(first);
+        const name = lastName(call.funcname);
+        const args = (call.args ?? []);
+        const alias = b.alias;
+        const aliasName = alias?.aliasname;
+        const colnames = names(alias?.colnames);
+        for (const item of items)
+            for (const f of (bodyOf(item).items ?? []))
+                if (isNode(f) && kindOf(f) === "FuncCall")
+                    this.inFrom.add(bodyOf(f));
+        const canonical = name.startsWith("jsonb");
+        switch (name) {
+            // jsonpath's rows, as Postgres finds them (src/duck/pg-eval.ts), unnested
+            case "jsonb_path_query": {
+                if (b.ordinality === true)
+                    throw new Unrewritable(`${name}() WITH ORDINALITY is not supported by Mason`, "number the rows with row_number() OVER () instead", "with-ordinality");
+                if (args.length < 2 || args.length > 4 || args.some((a) => kindOf(a) === "NamedArgExpr"))
+                    return null;
+                const list = pgCall("list", `ARRAY(SELECT mason_p::text FROM jsonb_path_query(${args.map((_, i) => `a${i + 1}::${JSONPATH_ARGS[i]}`).join(", ")}) AS mason_p)`, args);
+                const column = colnames[0] ?? aliasName ?? name;
+                const item = bodyOf(items[0]);
+                return { RangeFunction: { ...b, functions: [{ List: { ...item, items: [fn("unnest", [arrayCast(list, "json")]), ...item.items.slice(1)] } }], alias: { aliasname: aliasName ?? name, colnames: [S(column)] } } };
+            }
+            case "jsonb_array_elements":
+            case "json_array_elements":
+            case "jsonb_array_elements_text":
+            case "json_array_elements_text": {
+                if (b.ordinality === true)
+                    throw new Unrewritable(`${name}() WITH ORDINALITY is not supported by Mason`, "number the elements with row_number() OVER () instead", "with-ordinality");
+                const text = name.endsWith("_text");
+                const elements = fn("__mason_json_elements", [jsonArg(args[0]), boolConst(canonical), boolConst(text)]);
+                const list = text ? elements : arrayCast(elements, "json");
+                // a scalar function's column is named by its alias (or `value`), and so is DuckDB's unnest column here
+                const column = colnames[0] ?? aliasName ?? "value";
+                const unnest = fn("unnest", [list]);
+                const item = bodyOf(items[0]);
+                return { RangeFunction: { ...b, functions: [{ List: { ...item, items: [unnest, ...item.items.slice(1)] } }], alias: { aliasname: aliasName ?? name, colnames: [S(column)] } } };
+            }
+            case "generate_series": {
+                // a series of times as DuckDB's list, unnested: its table function of times answers no rows for EVERY outer row
+                // once one row's series is empty, when correlated (a LATERAL or a subquery; DuckDB 2.0.0, threads or none),
+                // where the list form and the series of integers are right
+                const type = this.typed({ FuncCall: call })?.type ?? null;
+                if (items.length !== 1 || (type !== TIMESTAMP && type !== TIMESTAMPTZ))
+                    return null;
+                if (b.ordinality === true)
+                    throw new Unrewritable(`${name}() of times WITH ORDINALITY is not supported by Mason`, "number the rows with row_number() OVER (ORDER BY the value) instead", "with-ordinality");
+                const column = colnames[0] ?? aliasName ?? name;
+                const item = bodyOf(items[0]);
+                return { RangeFunction: { ...b, functions: [{ List: { ...item, items: [fn("unnest", [first]), ...item.items.slice(1)] } }], alias: { aliasname: aliasName ?? name, colnames: [S(column)] } } };
+            }
+            case "jsonb_to_record":
+            case "json_to_record": {
+                // each column as Postgres reads it from the object (src/duck/pg-eval.ts, a chunk at a time), in a lateral row
+                const defs = (b.coldeflist ?? []).map((d) => bodyOf(d));
+                if (defs.length === 0 || args.length !== 1 || b.ordinality === true)
+                    return null;
+                const spelled = defs.map((d) => ({ name: String(d.colname), ...recordColumn(d.typeName) }));
+                const bad = spelled.find((c) => c.read === null);
+                if (bad !== undefined)
+                    throw new Unrewritable(`${name}() with a column of type ${bad.spelled} is not supported by Mason`, "read the column as text and cast it outside: AS x(c text)", "unverified");
+                const list = spelled.map((c) => `"${c.name.replaceAll('"', '""')}" ${c.spelled}`).join(", ");
+                const sub = {
+                    targetList: spelled.map((c) => {
+                        const [kind, duck] = c.read;
+                        const call = pgCall(kind, `(SELECT mason_r."${c.name.replaceAll('"', '""')}" FROM ${name}(a1::${canonical ? "jsonb" : "json"}) AS mason_r(${list}))`, [this.clone(args[0])]);
+                        return { ResTarget: { name: c.name, val: duck === null ? call : cast(call, duck) } };
+                    }),
+                    op: "SETOP_NONE",
+                };
+                this.done.add(sub);
+                return { RangeSubselect: { lateral: true, subquery: { SelectStmt: sub }, alias: { aliasname: aliasName ?? name } } };
+            }
+            case "jsonb_each":
+            case "json_each":
+            case "jsonb_each_text":
+            case "json_each_text": {
+                if (b.ordinality === true)
+                    throw new Unrewritable(`${name}() WITH ORDINALITY is not supported by Mason`, "number the members with row_number() OVER () instead", "with-ordinality");
+                const text = name.endsWith("_text");
+                // each member's key and value, two lists of one length that unnest side by side
+                const sub = {
+                    targetList: [
+                        { ResTarget: { name: colnames[0] ?? "key", val: fn("unnest", [fn("__mason_json_keys", [jsonArg(args[0]), boolConst(canonical)])]) } },
+                        { ResTarget: { name: colnames[1] ?? "value", val: fn("unnest", [fn("__mason_json_values", [this.clone(args[0]), boolConst(canonical), boolConst(text)])]) } },
+                    ],
+                    op: "SETOP_NONE",
+                };
+                this.done.add(sub);
+                return { RangeSubselect: { lateral: true, subquery: { SelectStmt: sub }, alias: { aliasname: aliasName ?? name } } };
+            }
+            case "jsonb_object_keys":
+            case "json_object_keys": {
+                const column = colnames[0] ?? aliasName ?? name;
+                const unnest = fn("unnest", [fn("__mason_json_keys", [args[0], boolConst(canonical)])]);
+                const item = bodyOf(items[0]);
+                return { RangeFunction: { ...b, functions: [{ List: { ...item, items: [unnest, ...item.items.slice(1)] } }], alias: { aliasname: aliasName ?? name, colnames: [S(column)] } } };
+            }
+            default: return null;
+        }
+    }
+}
+/** a cell an exact program cannot take (in a grouped SELECT, a column not grouped): the column stays DuckDB's */
+const NOT_EXACT = new Error("not exact");
+/** a SELECT list item that is `*` or `t.*` */
+/** a set operation's arm (libpg-query's `larg` / `rarg`: a SelectStmt's body, unwrapped), as the node it is */
+const armOf = (key, v) => (key === "larg" || key === "rarg") && v !== null && typeof v === "object" && !Array.isArray(v) && !isNode(v) ? { SelectStmt: v } : null;
+const hasStar = (v) => isNode(v) && kindOf(v) === "ColumnRef" && bodyOf(v).fields.some((f) => kindOf(f) === "A_Star");
+/** whether a program does what DuckDB would compute otherwise: a division, a rounding, a scale chosen per value; a
+ *  sum, a difference or a product of DuckDB's decimals is DuckDB's own right answer */
+function worthComputing(p) {
+    switch (p.op) {
+        // a parameter's cell is its text: DuckDB computes with it as a double
+        case "cell": return p.key.startsWith("$");
+        case "literal": return false;
+        // DuckDB's decimals may be fewer than Postgres's (src/duck/sync.ts copies a numeric(65,30) at its values' scale)
+        case "pad": return true;
+        case "add":
+        case "sub":
+        case "mul": return worthComputing(p.args[0]) || worthComputing(p.args[1]);
+        case "neg":
+        case "abs": return worthComputing(p.arg);
+        default: return true;
+    }
+}
+/** the program with each cell's key moved by `by` (the cells of the columns before it) */
+function offsetCells(p, by) {
+    switch (p.op) {
+        case "cell": return p.key.startsWith("$") ? p : { op: "cell", key: String(Number(p.key) + by) };
+        case "literal": return p;
+        case "add":
+        case "sub":
+        case "mul":
+        case "div":
+        case "mod": return { op: p.op, args: [offsetCells(p.args[0], by), offsetCells(p.args[1], by)] };
+        case "neg":
+        case "abs":
+        case "floor":
+        case "ceil": return { op: p.op, arg: offsetCells(p.arg, by) };
+        case "round":
+        case "trunc":
+        case "pad": return { op: p.op, arg: offsetCells(p.arg, by), scale: p.scale };
+        case "typmod": return { op: "typmod", arg: offsetCells(p.arg, by), precision: p.precision, scale: p.scale };
+        case "greatest":
+        case "least":
+        case "coalesce": return { op: p.op, args: p.args.map((x) => offsetCells(x, by)) };
+        case "stddev": return { ...p, args: [offsetCells(p.args[0], by), offsetCells(p.args[1], by), offsetCells(p.args[2], by)] };
+        case "pick": return { op: "pick", index: offsetCells(p.index, by), args: p.args.map((x) => offsetCells(x, by)) };
+        case "rescale": return { op: "rescale", arg: offsetCells(p.arg, by), scale: offsetCells(p.scale, by) };
+    }
+}
+/** an expression's shape: its tree without offsets */
+const shapeOf = (n) => JSON.stringify(n, (k, v) => k === "location" ? undefined : v);
+const strip = (n) => kindOf(n) === "CollateClause" ? bodyOf(n).arg : n;
+/** glibc's order, as the source was MEASURED to order text (src/duck/libc-order.ts: its levels as one text, ICU's
+ *  accent and case levels over the characters of the first), then the bytes, as Postgres breaks a tie */
+function libcKeys(copy, e, icu) {
+    return [fn("__mason_libc_key", [copy(e), fn("icu_sort_key", [fn("__mason_libc_kept", [copy(e)]), strConst(icu)])]), e];
+}
+/** the libc keys as ONE text that orders as they do: the key, a space (below every hex digit, so a shorter key
+ *  orders first), the value's own bytes in hex */
+function libcKey(copy, e, icu) {
+    const [key, bytes] = libcKeys(copy, e, icu);
+    return concat(key, strConst(" "), fn("hex", [bytes]));
+}
+/** Postgres's array types whose elements are DuckDB's of these names */
+/**
+ * A date's or timestamp's datum (src/duck/pgtree.ts `datumBytes`) as ISO text DuckDB reads back to the same value: a
+ * date is days since 2000-01-01 (int32), a timestamp microseconds (int64), little-endian; a year before 1 is
+ * astronomical (`-0043` is 44 BC), a timestamptz's in UTC (`+00`). Null where the bytes are not one.
+ */
+/** an IPv6 address as Postgres writes it (inet_net_ntop): the longest run of two or more zero words as `::` (the first
+ *  such run), hex words without leading zeros, and an IPv4-compatible or -mapped address's tail in dotted form */
+export function ipv6Text(addr) {
+    const words = Array.from({ length: 8 }, (_, i) => (addr[2 * i] << 8) | addr[2 * i + 1]);
+    let best = { base: -1, len: 0 }, cur = { base: -1, len: 0 };
+    words.forEach((w, i) => {
+        if (w === 0) {
+            if (cur.base < 0)
+                cur = { base: i, len: 1 };
+            else
+                cur.len++;
+        }
+        else if (cur.base >= 0) {
+            if (best.base < 0 || cur.len > best.len)
+                best = cur;
+            cur = { base: -1, len: 0 };
+        }
+    });
+    if (cur.base >= 0 && (best.base < 0 || cur.len > best.len))
+        best = cur;
+    if (best.base >= 0 && best.len < 2)
+        best = { base: -1, len: 0 };
+    const dotted = best.base === 0 && (best.len === 6 || (best.len === 5 && words[5] === 0xffff) || (best.len === 7 && words[7] !== 1));
+    let out = "";
+    for (let i = 0; i < 8; i++) {
+        if (best.base >= 0 && i >= best.base && i < best.base + best.len) {
+            if (i === best.base)
+                out += "::";
+            continue;
+        }
+        if (i !== 0 && !out.endsWith(":"))
+            out += ":";
+        if (i === 6 && dotted) {
+            out += addr.slice(12, 16).join(".");
+            break;
+        }
+        out += words[i].toString(16);
+    }
+    return out;
+}
+/** an inet's output text: a full mask dropped (`/32` of an IPv4, `/128` of an IPv6), as inet_out writes it */
+const inetOut = (n) => fn("regexp_replace", [fn("regexp_replace", [n, strConst("^([0-9.]+)/32$"), strConst("\\1")]), strConst("^([0-9a-f:.]+)/128$"), strConst("\\1")]);
+/** An interval's datum: microseconds (int64), days, months (int32), little-endian; null for an infinite one, which
+ *  DuckDB has no counterpart of */
+export function intervalDatum(bytes) {
+    if (bytes.length !== 16)
+        return null;
+    const le = (at, n) => { let v = 0n; for (let i = n - 1; i >= 0; i--)
+        v = (v << 8n) | BigInt(bytes[at + i]); return BigInt.asIntN(n * 8, v); };
+    const micros = le(0, 8), days = Number(le(8, 4)), months = Number(le(12, 4));
+    if (months === 2147483647 || months === -2147483648)
+        return null;
+    return { months, days, micros };
+}
+export function datumText(type, bytes) {
+    const le = (n) => { let v = 0n; for (let i = n - 1; i >= 0; i--)
+        v = (v << 8n) | BigInt(bytes[i]); return BigInt.asIntN(n * 8, v); };
+    const civil = (days) => {
+        // days since 1970-01-01 → a proleptic Gregorian date (Howard Hinnant's civil_from_days)
+        const z = days + 719468n, era = (z >= 0n ? z : z - 146096n) / 146097n, doe = z - era * 146097n;
+        const yoe = (doe - doe / 1460n + doe / 36524n - doe / 146096n) / 365n, doy = doe - (365n * yoe + yoe / 4n - yoe / 100n);
+        const mp = (5n * doy + 2n) / 153n, d = doy - (153n * mp + 2n) / 5n + 1n, m = mp < 10n ? mp + 3n : mp - 9n;
+        const y = yoe + era * 400n + (m <= 2n ? 1n : 0n);
+        const year = y < 0n ? `-${String(-y).padStart(4, "0")}` : String(y).padStart(4, "0");
+        return `${year}-${String(m).padStart(2, "0")}-${String(d).padStart(2, "0")}`;
+    };
+    if (type === INET) {
+        // a varlena: a 4-byte header, the family (2 IPv4, 3 IPv6), the mask's bits, the address
+        if (bytes.length < 10)
+            return null;
+        const family = bytes[4], bits = bytes[5], addr = bytes.slice(6);
+        if (family === 2 && addr.length >= 4)
+            return `${addr.slice(0, 4).join(".")}/${bits}`;
+        if (family === 3 && addr.length >= 16)
+            return `${ipv6Text(addr.slice(0, 16))}/${bits}`;
+        return null;
+    }
+    if (type === DATE) {
+        if (bytes.length !== 4)
+            return null;
+        const v = le(4);
+        if (v === -2147483648n)
+            return "-infinity";
+        if (v === 2147483647n)
+            return "infinity";
+        return civil(v + 10957n);
+    }
+    if (bytes.length !== 8)
+        return null;
+    const v = le(8);
+    if (v === -(1n << 63n))
+        return "-infinity";
+    if (v === (1n << 63n) - 1n)
+        return "infinity";
+    const micros = v + 946684800000000n, day = 86400000000n;
+    const days = micros >= 0n ? micros / day : -((-micros + day - 1n) / day), rest = micros - days * day;
+    const hh = rest / 3600000000n, mm = (rest / 60000000n) % 60n, ss = (rest / 1000000n) % 60n, us = rest % 1000000n;
+    const time = `${String(hh).padStart(2, "0")}:${String(mm).padStart(2, "0")}:${String(ss).padStart(2, "0")}.${String(us).padStart(6, "0")}`;
+    return `${civil(days)} ${time}${type === TIMESTAMPTZ ? "+00" : ""}`;
+}
+/** an array type whose elements' DuckDB text is Postgres's, and how each is written into json: smallint, integer, bigint
+ *  and boolean as they are, text, varchar and uuid as strings, jsonb canonical, json as written */
+const JSON_ARRAY_ELEMENT = { 1005: "r", 1007: "r", 1016: "r", 1000: "r", 1009: "s", 1015: "s", 2951: "s", 3807: "k", 199: "r" };
+const ARRAY_DUCK = { 1009: "varchar", 1015: "varchar", 1014: "varchar", 1007: "integer", 1016: "bigint", 1005: "smallint", 1022: "double", 1021: "real", 1000: "boolean", 1182: "date", 1115: "timestamp", 1185: "timestamptz", 2951: "uuid" };
+/** (a1, b1) OVERLAPS (a2, b2), as Postgres's overlaps_timestamp decides it, NULLs included: each period's ends in
+ *  order (a NULL start takes the end's place), then the SQL standard's cases */
+function overlaps(copy, a1, b1, a2, b2) {
+    const start = (a, b) => caseWhen([[isNull(copy(a)), copy(b)], [and([isNotNull(copy(b)), op(">", copy(a), copy(b))]), copy(b)]], copy(a));
+    const end = (a, b) => caseWhen([[isNull(copy(a)), nullConst()], [and([isNotNull(copy(b)), op(">", copy(a), copy(b))]), copy(a)]], copy(b));
+    const s1 = () => start(a1, b1), e1 = () => end(a1, b1), s2 = () => start(a2, b2), e2 = () => end(a2, b2);
+    const T = boolConst(true), F = () => boolConst(false);
+    return caseWhen([
+        [or([isNull(s1()), isNull(s2())]), nullConst()],
+        [op(">", s1(), s2()), caseWhen([[isNull(e2()), nullConst()], [op("<", s1(), e2()), T], [isNull(e1()), nullConst()]], F())],
+        [op("<", s1(), s2()), caseWhen([[isNull(e1()), nullConst()], [op("<", s2(), e1()), boolConst(true)], [isNull(e2()), nullConst()]], F())],
+    ], caseWhen([[or([isNull(e1()), isNull(e2())]), nullConst()]], boolConst(true)));
+}
+/**
+ * A json read by its steps (a JSON array of keys and indexes, src/duck/functions.ts jsonGet), native where DuckDB's
+ * answer is Postgres's, the function's for the rest.
+ *
+ * THE FUNCTION IS A HOP TO THE MAIN THREAD PER VECTOR (the test server: 4.5 µs a row, a `->>` over 22 M
+ * rows took 98 s and every other session, the stream and the commands waited for it). A `->>` / `#>>` of a column
+ * is answered by DuckDB's own JSON reader where that reader answers exactly as Postgres does — a STRING value is the
+ * same text from json_extract_string as from the function, a missing path (json_type's NULL) or a JSON null (its
+ * 'NULL') is SQL NULL on both — and by
+ * the function for every other value (a number, whose digits Postgres keeps as written where DuckDB writes `7.0`; an
+ * object or an array, whose spacing is Postgres's): the CASE's ELSE, which DuckDB evaluates on those rows only
+ * (measured: 10,000 number rows of 100,000 reached the function, in 49 vectors). Measured over 5 M rows: 3.85 s
+ * through the function, 0.10 s native.
+ *  - Only a COLUMN's json is read natively (a chain of reads off one included, folded into one read: jsonChain): a literal
+ *    or an expression cast to json is validated by Postgres's rules inside the function, where DuckDB's parser would
+ *    refuse it in its own words.
+ *  - A document may hold a key twice, of which Postgres reads the LAST and DuckDB the first: the read is native only
+ *    where every object on the way holds each key once (json_keys at each step), unless `keysOnce` says the text holds
+ *    each once — jsonb's canonical text as the copy holds it (a copied table's column, Rewriter.jsonRead). A `json`
+ *    column is the document as written; a jsonb the statement computes (jsonb_object_agg, jsonb_build_object) is the
+ *    rewrite's text, a key twice included (a review finding).
+ *  - `j` is placed in every arm of the CASE, and each placement is its own copy (`copy`, the rewriter's clone): the
+ *    walker runs a node's rule once, so a node placed twice would be qualified or renamed in its first place alone
+ *    (`"Doc"` beside another table's `doc` was ambiguous to DuckDB, 42804; a review finding).
+ *  - Steps are keys only: an index, or a `#>` element that reads as one (pathIndex, the function's own definition: ` 1`
+ *    and `+1` are, `1 ` is not), stays the function's (a negative one counts from the end, and jsonb reads a scalar as
+ *    a one-element array). A pointer reads only an all-digit element as an index, so every other element is a key to
+ *    it, as to Postgres. The path is a JSON pointer (`/a/b`, `~` and `/`
+ *    escaped), which takes every key — except an all-digit key, which a pointer reads as an index on an array where
+ *    Postgres reads NULL: a path with one is JSONPath's quoted keys, which cannot say `*` (a wildcard even quoted)
+ *    or an empty key, so those stay the function's.
+ * `->` (the json itself) stays the function's: a string's quoting and escapes are rewritten by DuckDB's writer.
+ * tests/duck-wire.test.ts "a ->> of a column is DuckDB's own read" holds the answers and counts the hops.
+ */
+function jsonGet(copy, j, steps, either, canonical, asText, keysOnce) {
+    const call = fn("__mason_json_get", [jsonArg(copy(j)), steps, boolConst(either), boolConst(canonical), boolConst(asText)]);
+    if (!asText || kindOf(j) !== "ColumnRef")
+        return call;
+    const literal = constString(steps);
+    if (literal === null)
+        return call;
+    const keys = [];
+    for (const s of JSON.parse(literal)) {
+        // a `->` step that is an integer is an index; a `#>` element that reads as one is an index on an array, as the
+        // function reads it (pathIndex: `+1` and ` 1` are, `1 ` is a key)
+        if (typeof s !== "string" || (either && pathIndex(s) !== null) || /[\u0000-\u001f]/.test(s))
+            return call;
+        keys.push(s);
+    }
+    if (keys.length === 0)
+        return call;
+    const pointer = (ks) => ks.map((k) => "/" + k.replaceAll("~", "~0").replaceAll("/", "~1")).join("");
+    let path;
+    if (keys.some((k) => /^\d+$/.test(k))) {
+        if (keys.some((k) => k === "" || k === "*"))
+            return call;
+        path = "$" + keys.map((k) => `."${k.replaceAll("\\", "\\\\").replaceAll('"', '\\"')}"`).join("");
+    }
+    else
+        path = pointer(keys);
+    const type = () => fn("json_type", [copy(j), strConst(path)]);
+    // each object on the way holds every key once (json_keys of an array or a scalar is empty, of a missing path NULL:
+    // the read there is NULL on both sides, so both pass)
+    // (made again for each arm that tests it: every node is placed once)
+    const once = () => keysOnce ? [] : keys.map((_, i) => {
+        const at = () => fn("json_keys", i === 0 ? [copy(j)] : [copy(j), strConst(pointer(keys.slice(0, i)))]);
+        return { CoalesceExpr: { args: [op("=", fn("len", [at()]), fn("len", [fn("list_distinct", [at()])])), boolConst(true)] } };
+    });
+    const when = (test) => keysOnce ? test : and([...once(), test]);
+    return caseWhen([
+        // (a NULL document first: its json_keys is NULL, which no check passes)
+        [isNull(copy(j)), nullConst()],
+        [when(op("=", type(), strConst("VARCHAR"))), fn("json_extract_string", [copy(j), strConst(path)])],
+        // a missing path is SQL NULL from json_type, a JSON null its name
+        [when(or([isNull(type()), op("=", type(), strConst("NULL"))])), nullConst()],
+    ], call);
+}
+/**
+ * A STORED PATH'S `->>`, FROM ITS COLUMN ALONE (Rewriter.keptRead): the column holds the `->` answer — the value's JSON
+ * text — or `KEPT_NULL`, and `->>` is that text where the value is not a string (a number's text is the same both ways,
+ * a jsonb's numeric included; an object or an array its text), NULL for a JSON null or no value, and a string's
+ * characters: its text between the quotes where it holds no escape, else the function's `->>` of the value's own text
+ * (`[]` steps) — the same function on the same value, only for the rows that take that arm, never the document.
+ */
+function keptText(column, canonical) {
+    return caseWhen([
+        [or([op("=", column(), fn("chr", [intConst(0)])), op("=", column(), strConst("null"))]), nullConst()],
+        [fn("starts_with", [column(), strConst('"')]), caseWhen([
+                [fn("contains", [column(), strConst("\\")]), fn("__mason_json_get", [column(), strConst("[]"), boolConst(false), boolConst(canonical), boolConst(true)])],
+            ], fn("substr", [column(), intConst(2), op("-", fn("length", [column()]), intConst(2))]))],
+    ], column());
+}
+/** `->`'s key (an integer one an index) or json_extract_path's elements, as the JSON array of steps */
+function jsonSteps(keys, index) {
+    const literal = keys.map((k) => index ? constInt(k) : constString(k));
+    if (literal.every((k) => k !== null))
+        return strConst(JSON.stringify(literal));
+    return cast(fn("to_json", [fn("list_value", keys.map((k) => cast(k, [index ? "bigint" : "varchar"])))]), ["varchar"]);
+}
+/** Postgres's text-array element types, as DuckDB's */
+const ARRAY_ELEMENT = { text: "varchar", varchar: "varchar", int4: "integer", int: "integer", integer: "integer", int8: "bigint", bigint: "bigint", int2: "smallint", smallint: "smallint", float8: "double", numeric: "double", bool: "boolean", boolean: "boolean", date: "date" };
+/** an array literal's elements as array_in reads them: quotes and backslashes, an unquoted NULL is NULL */
+function arrayLiteral(text) {
+    const inner = text.trim();
+    if (!inner.startsWith("{") || !inner.endsWith("}"))
+        throw new Unrewritable(`malformed array literal: "${text}"`, 'write it as \'{a,b}\'', { postgres: "22P02" });
+    const body = inner.slice(1, -1);
+    if (body.trim() === "")
+        return [];
+    const out = [];
+    let cur = "", quoted = false, wasQuoted = false;
+    for (let i = 0; i < body.length; i++) {
+        const c = body[i];
+        if (quoted) {
+            if (c === "\\") {
+                cur += body[++i] ?? "";
+                continue;
+            }
+            if (c === '"') {
+                quoted = false;
+                continue;
+            }
+            cur += c;
+            continue;
+        }
+        if (c === "{")
+            throw new Unrewritable("a multi-dimensional array literal is not supported by Mason", "write a one-dimensional array", "multidim-array");
+        if (c === '"') {
+            quoted = true;
+            wasQuoted = true;
+            continue;
+        }
+        if (c === "\\") {
+            cur += body[++i] ?? "";
+            continue;
+        }
+        if (c === ",") {
+            out.push(!wasQuoted && cur.trim().toUpperCase() === "NULL" ? null : wasQuoted ? cur : cur.trim());
+            cur = "";
+            wasQuoted = false;
+            continue;
+        }
+        cur += c;
+    }
+    out.push(!wasQuoted && cur.trim().toUpperCase() === "NULL" ? null : wasQuoted ? cur : cur.trim());
+    return out;
+}
+/**
+ * A SIMILAR TO pattern as RE2's, as Postgres's similar_to_escape translates it: `%` any text, `_` one character, the
+ * escape character's next character itself, `.` `^` `$` themselves, and the regular-expression operators (`|` `*` `+`
+ * `?` `{…}` `(…)` `[…]`) as they are. The whole text must match (regexp_full_match).
+ */
+export function similarToRe2(pattern, escape) {
+    if (escape.length > 1)
+        throw new Unrewritable("invalid escape string", "Escape string must be empty or one character.", { postgres: "22025" });
+    let out = "", inClass = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (escape !== "" && c === escape) {
+            const next = pattern[++i];
+            if (next === undefined)
+                throw new Unrewritable("invalid escape at the end of a SIMILAR TO pattern", "escape a character, or end the pattern without the escape character", { postgres: "22025" });
+            if (next === '"')
+                throw new Unrewritable("SIMILAR TO's substring markers (escape + \") are not supported by Mason", "use substring(text from pattern) with a POSIX regular expression", "similar-to-forms");
+            out += /[A-Za-z0-9]/.test(next) ? next : `\\${next}`;
+            continue;
+        }
+        if (inClass) {
+            out += c === "\\" ? "\\\\" : c;
+            if (c === "]")
+                inClass = false;
+            continue;
+        }
+        if (c === "[") {
+            inClass = true;
+            out += c;
+            if (pattern[i + 1] === "^") {
+                out += "^";
+                i++;
+            }
+            if (pattern[i + 1] === "]") {
+                out += "\\]";
+                i++;
+            }
+            continue;
+        }
+        if (c === "%") {
+            out += ".*";
+            continue;
+        }
+        if (c === "_") {
+            out += ".";
+            continue;
+        }
+        if (c === "(") {
+            out += pattern[i + 1] === "?" ? "(" : "(?:";
+            continue;
+        }
+        if (".^$\\".includes(c)) {
+            out += `\\${c}`;
+            continue;
+        }
+        out += c;
+    }
+    return out;
+}
+/** the parenthesised groups of a regular expression that capture (`(?:…)` does not; inside […] a parenthesis is a character) */
+function captureGroups(pattern) {
+    let n = 0, inClass = false;
+    for (let i = 0; i < pattern.length; i++) {
+        const c = pattern[i];
+        if (c === "\\") {
+            i++;
+            continue;
+        }
+        if (inClass) {
+            if (c === "]")
+                inClass = false;
+            continue;
+        }
+        if (c === "[") {
+            inClass = true;
+            if (pattern[i + 1] === "^")
+                i++;
+            if (pattern[i + 1] === "]")
+                i++;
+            continue;
+        }
+        if (c === "(" && pattern[i + 1] !== "?")
+            n++;
+    }
+    return n;
+}
+/** pg_catalog.interval's field masks (INTERVAL_MASK): the lowest field a typmod names, finest first */
+const INTERVAL_FIELDS = [[1 << 12, "second"], [1 << 11, "minute"], [1 << 10, "hour"], [1 << 3, "day"], [1 << 1, "month"], [1 << 2, "year"]];
+/** `interval '3' day`, `x::interval hour`: a bare number is a count of the lowest field, and the fields below it are
+ *  cut off (AdjustIntervalForTypmod), as date_trunc cuts an interval */
+function intervalFields(arg, mask) {
+    const unit = INTERVAL_FIELDS.find(([bit]) => mask !== null && (mask & bit) !== 0)?.[1] ?? "second";
+    const s = constString(arg);
+    const value = s !== null && /^\s*[+-]?(\d+\.?\d*|\.\d+)\s*$/.test(s) ? strConst(`${s.trim()} ${unit}s`) : arg;
+    const iv = cast(value, ["interval"]);
+    return unit === "second" ? iv : fn("date_trunc", [strConst(unit), iv]);
+}
+/** a json_to_record column definition's type, spelled for Postgres, and how its value comes back to DuckDB (the
+ *  worker's kind and the DuckDB type it is cast to); `read` null for a type not read here (an array, a type of a
+ *  schema's own) */
+function recordColumn(t) {
+    const name = lastName(t?.names);
+    const mods = (t?.typmods ?? []).map((m) => constInt(m));
+    const spelled = `${name}${mods.length > 0 ? `(${mods.join(", ")})` : ""}${Array.isArray(t?.arrayBounds) && t.arrayBounds.length > 0 ? "[]" : ""}`;
+    if (spelled.endsWith("]") || mods.some((m) => m === null) || (t?.names ?? []).length > 2)
+        return { spelled, read: null };
+    const reads = {
+        int2: ["int8", ["smallint"]], int4: ["int8", ["integer"]], int8: ["int8", null], bool: ["bool", null], date: ["date", null],
+        timestamp: ["timestamp", null], timestamptz: ["timestamptz", null], interval: ["interval", null], text: ["text", null],
+        varchar: ["text", null], bpchar: ["text", null], float8: ["text", ["double"]], float4: ["text", ["float"]], uuid: ["text", ["uuid"]],
+        json: ["text", ["json"]], jsonb: ["text", ["json"]],
+        numeric: ["text", mods.length > 0 && mods[0] <= 38 ? ["decimal", String(mods[0]), String(mods[1] ?? 0)] : ["double"]],
+    };
+    return { spelled, read: reads[name] ?? null };
+}
+/** json_agg's text of items each written with its own line break before it (`\n {…}`, `null`): `[` the items joined by
+ *  `, ` `]`, the first item's line break dropped, as json_agg_transfn writes none before the first */
+function linedAgg(b, item, done) {
+    const agg = { FuncCall: { ...b, funcname: [S("string_agg")], args: [item, strConst(", ")] } };
+    done.add(bodyOf(agg));
+    return concat(strConst("["), fn("regexp_replace", [agg, strConst("^\n "), strConst("")]), strConst("]"));
+}
+/** the divisor of a float or numeric division: Postgres raises on zero */
+function nonZero(copy, r) {
+    // a constant, or a constant the rewrite cast (`CAST(2 AS double)`): no guard, so no volatile error() call, which DuckDB
+    // refuses in a DISTINCT aggregate's ORDER BY
+    let c = r;
+    while (kindOf(c) === "TypeCast" && isNode(bodyOf(c).arg))
+        c = bodyOf(c).arg;
+    if (kindOf(c) === "A_Const") {
+        const b = bodyOf(c);
+        const v = b.ival !== undefined ? Number(b.ival.ival ?? 0) : b.fval !== undefined ? Number(b.fval.fval) : null;
+        if (v !== null && v !== 0)
+            return r;
+    }
+    // NULL in the branch no row takes: the CASE keeps the divisor's type
+    return caseWhen([[fn("__mason_zero_divisor", [op("=", r, intConst(0))]), nullConst()]], copy(r));
+}
+/** a decimal text without an exponent: `1.5e-3` → `0.0015` */
+function positional(text) {
+    const m = /^([+-]?)(\d*)(?:\.(\d*))?(?:[eE]([+-]?\d+))?$/.exec(text);
+    if (m === null)
+        return text;
+    const digits = `${m[2] ?? ""}${m[3] ?? ""}`;
+    const point = (m[2] ?? "").length + Number(m[4] ?? 0);
+    let whole, frac;
+    if (point <= 0) {
+        whole = "0";
+        frac = "0".repeat(-point) + digits;
+    }
+    else if (point >= digits.length) {
+        whole = digits + "0".repeat(point - digits.length);
+        frac = "";
+    }
+    else {
+        whole = digits.slice(0, point);
+        frac = digits.slice(point);
+    }
+    whole = whole.replace(/^0+(?=\d)/, "") || "0";
+    return `${m[1] === "-" ? "-" : ""}${whole}${frac === "" ? "" : `.${frac}`}`;
+}
+/** a numeric constant written positionally, as DuckDB's DECIMAL: `0.025` reads as one, but a whole `250` (from `2.5e2`)
+ *  would read back as an INTEGER — integer arithmetic, an overflow where Postgres's numeric has none — so it is cast,
+ *  as an integer cast to numeric is, to DECIMAL(38, 0) (DuckDB keeps a product of two 18-digit decimals in 64 bits and
+ *  fails past it). Past DuckDB's 38 digits it stays as written: DuckDB's double, as before */
+function decimalConst(text) {
+    if (text.includes(".") || text.replace(/^-/, "").length > 38)
+        return numConst(text);
+    const n = Number(text);
+    return cast(Number.isSafeInteger(n) && n >= -2147483648 && n <= 2147483647 ? intConst(n) : numConst(text), ["decimal", "38", "0"]);
+}
+/** a text cast to an integer, as strict as Postgres's: whitespace around an optional sign and digits, nothing else */
+/** the jsonpath functions' arguments: the target, the path, the variables, `silent` */
+const JSONPATH_ARGS = ["jsonb", "jsonpath", "jsonb", "boolean"];
+/** Postgres's own answer for each row (src/duck/pg-eval.ts): `template` over a1…an, each argument's text, under the
+ *  zone DuckDB's session has */
+function pgCall(kind, template, args) {
+    return fn(`__mason_pg_${kind}`, [fn("current_setting", [strConst("TimeZone")]), strConst(template), ...args.map((a) => cast(a, ["varchar"]))]);
+}
+/** a json argument: a text literal is read as JSON (DuckDB's json functions over a VARCHAR literal parse it anyway) */
+const jsonArg = (n) => n;
+/** `#>` / `#>>`'s path (a text array: a literal `'{a,b,1}'` or an expression) as the JSON array of its elements */
+function jsonPath(r) {
+    const s = constString(r);
+    if (s === null)
+        return cast(fn("to_json", [r]), ["varchar"]);
+    const elements = arrayLiteral(s);
+    if (elements.some((e) => e === null))
+        return nullConst();
+    return strConst(JSON.stringify(elements));
+}
+/**
+ * A Postgres (ARE) pattern as RE2's: `.` matches a newline (Postgres's default; RE2's `(?s)`), `\w` / `\d` / `\s` are
+ * Unicode's (RE2's are ASCII), `\Z` is the end (`\z`). Null where RE2 would not answer as Postgres's engine does, which
+ * then answers it (src/duck/pg-eval.ts): a pattern that is not a literal; a construct RE2 lacks or reads otherwise — a
+ * lookaround, a back reference, embedded options, a word boundary or a word's start or end (`\y`, `\m`, `\M`: RE2's
+ * `\b` knows ASCII words alone); and, `extract`, a pattern whose MATCH (not whether there is one) depends on the
+ * engine: alternation, or more than one quantifier (Postgres takes the longest match, RE2 the first: `substring('aab'
+ * from 'a*(ab)?')` is `aab` there, `aa` in RE2).
+ */
+function regexPattern(p, extract = false) {
+    const s = constString(p);
+    if (s === null)
+        return null;
+    const re = areToRe2(s, extract);
+    return re === null ? null : strConst(`(?s)${re}`);
+}
+export function areToRe2(s, extract = false) {
+    if (s.startsWith("***"))
+        return null;
+    let out = "", inClass = false, quantifiers = 0;
+    for (let i = 0; i < s.length; i++) {
+        const c = s[i];
+        if (c === "\\" && i + 1 < s.length) {
+            const e = s[i + 1];
+            i++;
+            const cls = { w: "\\p{L}\\p{Nd}_", d: "\\p{Nd}", s: "\\s" }[e];
+            if (cls !== undefined) {
+                out += inClass ? cls : `[${cls}]`;
+                continue;
+            }
+            const neg = { W: "\\p{L}\\p{Nd}_", D: "\\p{Nd}" }[e];
+            if (neg !== undefined && !inClass) {
+                out += `[^${neg}]`;
+                continue;
+            }
+            // a word boundary, start or end; a back reference (\1, \k<…>): Postgres's engine
+            if (!inClass && /[yYmM1-9k]/.test(e))
+                return null;
+            if (!inClass && e === "Z") {
+                out += "\\z";
+                continue;
+            }
+            out += `\\${e}`;
+            continue;
+        }
+        if (c === "[" && !inClass) {
+            inClass = true;
+            out += c;
+            if (s[i + 1] === "^") {
+                out += "^";
+                i++;
+            }
+            if (s[i + 1] === "]") {
+                out += "\\]";
+                i++;
+            }
+            continue;
+        }
+        if (c === "]" && inClass) {
+            inClass = false;
+            out += c;
+            continue;
+        }
+        if (!inClass) {
+            // a lookaround, embedded options, a comment: everything after `(?` but a group that only groups
+            if (c === "(" && s[i + 1] === "?" && s[i + 2] !== ":")
+                return null;
+            if (c === "|")
+                quantifiers += 2;
+            // a group that may match nothing (`(b)?`, `(b)*`): RE2's extract has no unmatched group ('' where Postgres has NULL)
+            if (extract && (c === "?" || c === "*" || c === "{") && s[i - 1] === ")")
+                return null;
+            // a quantifier (a `?` after one makes it lazy, and is none of its own)
+            if (c === "*" || c === "+" || c === "{" || (c === "?" && !/[*+?}]/.test(s[i - 1] ?? "") && s[i - 1] !== "("))
+                quantifiers++;
+        }
+        out += c;
+    }
+    return extract && quantifiers > 1 ? null : out;
+}
+/** regexp_replace's replacement: Postgres's `\&` is the whole match, RE2's `\0` */
+function replacement(r) {
+    const s = constString(r);
+    if (s === null)
+        return fn("replace", [r, strConst("\\&"), strConst("\\0")]);
+    return strConst(s.replace(/\\(.)/g, (_m, c) => c === "&" ? "\\0" : `\\${c}`));
+}
+/** substring(text FROM pattern): the first parenthesised part when there is one, else the whole match; NULL without one */
+function regexSubstring(copy, s, p) {
+    const pattern = regexPattern(p, true);
+    const text = constString(p);
+    const group = text !== null && /\((?!\?)/.test(text.replace(/\\./g, "")) ? 1 : 0;
+    return caseWhen([[fn("regexp_matches", [copy(s), copy(pattern)]), fn("regexp_extract", [s, pattern, intConst(group)])]], null);
+}
+/** make_interval(years, months, weeks, days, hours, mins, secs), positional or named, as DuckDB's interval sums */
+function makeInterval(args) {
+    const order = ["years", "months", "weeks", "days", "hours", "mins", "secs"];
+    const parts = new Map();
+    args.forEach((a, i) => {
+        if (kindOf(a) === "NamedArgExpr")
+            parts.set(String(bodyOf(a).name), bodyOf(a).arg);
+        else
+            parts.set(order[i], a);
+    });
+    const terms = [];
+    const add = (key, f) => { const x = parts.get(key); if (x !== undefined)
+        terms.push(f(x)); };
+    add("years", (x) => fn("to_years", [cast(x, ["integer"])]));
+    add("months", (x) => fn("to_months", [cast(x, ["integer"])]));
+    add("weeks", (x) => fn("to_days", [op("*", cast(x, ["integer"]), intConst(7))]));
+    add("days", (x) => fn("to_days", [cast(x, ["integer"])]));
+    add("hours", (x) => fn("to_hours", [cast(x, ["bigint"])]));
+    add("mins", (x) => fn("to_minutes", [cast(x, ["bigint"])]));
+    add("secs", (x) => fn("to_microseconds", [cast(fn("round", [op("*", cast(x, ["double"]), numConst("1000000.0"))]), ["bigint"])]));
+    if (terms.length === 0)
+        return cast(strConst("0 seconds"), ["interval"]);
+    return terms.reduce((a, b) => op("+", a, b));
+}
+/** jsonb_typeof: DuckDB's json_type in Postgres's words */
+function jsonTypeof(x) {
+    const t = fn("json_type", [x]);
+    return { CaseExpr: { arg: t, args: [["OBJECT", "object"], ["ARRAY", "array"], ["VARCHAR", "string"], ["BIGINT", "number"], ["UBIGINT", "number"], ["DOUBLE", "number"], ["HUGEINT", "number"], ["BOOLEAN", "boolean"], ["NULL", "null"]]
+                .map(([w, r]) => ({ CaseWhen: { expr: strConst(w), result: strConst(r) } })) } };
+}
+/** format(fmt, …) with only `%s` and `%%`: DuckDB's printf, each value as its text and NULL as nothing (Postgres's) */
+function formatCall(args, text) {
+    const fmt = constString(args[0]);
+    if (fmt === null || /%(?![s%])/.test(fmt))
+        throw new Unrewritable("format() with a format other than %s is not supported by Mason", "concatenate the parts with ||, or use only %s", "format-specifiers");
+    return fn("printf", [strConst(fmt), ...args.slice(1).map((a, i) => ({ CoalesceExpr: { args: [text(a, i + 1), strConst("")] } }))]);
+}
+/** Postgres's to_char / to_timestamp template patterns, as strftime / strptime's (null where strftime has none) */
+const TEMPLATE = [
+    ["HH24", "%H"], ["HH12", "%I"], ["HH", "%I"], ["MI", "%M"], ["SS", "%S"], ["MS", "%g"], ["US", "%f"],
+    ["AM", "%p"], ["PM", "%p"], ["am", "%p"], ["pm", "%p"],
+    ["YYYY", "%Y"], ["IYYY", "%G"], ["YY", "%y"], ["MONTH", null], ["Month", "%B"], ["month", null], ["MON", null], ["Mon", "%b"], ["mon", null], ["MM", "%m"],
+    ["DAY", null], ["Day", "%A"], ["day", null], ["DY", null], ["Dy", "%a"], ["dy", null], ["DDD", "%j"], ["DD", "%d"], ["IW", "%V"], ["TZ", "%Z"],
+];
+function translateTemplate(fmt, forParse) {
+    let out = "", i = 0;
+    while (i < fmt.length) {
+        if (fmt[i] === '"') {
+            const end = fmt.indexOf('"', i + 1);
+            const lit = fmt.slice(i + 1, end < 0 ? undefined : end);
+            out += lit.replace(/%/g, "%%");
+            i = end < 0 ? fmt.length : end + 1;
+            continue;
+        }
+        if (fmt.startsWith("FM", i)) {
+            i += 2;
+            continue;
+        }
+        const hit = TEMPLATE.find(([p]) => fmt.startsWith(p, i));
+        if (hit !== undefined) {
+            const [pattern, spec] = hit;
+            // Month / Day pad to 9 characters in Postgres unless FM: refused there rather than answered unpadded
+            const padded = (pattern === "Month" || pattern === "Day") && !fmt.slice(Math.max(0, i - 2), i).startsWith("FM");
+            if (spec === null || (padded && !forParse))
+                throw new Unrewritable(`the to_char pattern ${pattern}${padded ? " (padded to 9 characters)" : ""} is not supported by Mason`, padded ? `write FM${pattern} for the unpadded name` : "use YYYY MM DD HH24 MI SS MS US Mon Month Dy Day IYYY IW DDD AM", "to-char-patterns");
+            out += spec;
+            i += pattern.length;
+            continue;
+        }
+        if (/[A-Za-z]/.test(fmt[i])) {
+            const word = /^[A-Za-z]+/.exec(fmt.slice(i))[0];
+            throw new Unrewritable(`the to_char pattern ${word} is not supported by Mason`, "use YYYY MM DD HH24 MI SS MS US Mon Month Dy Day IYYY IW DDD AM, or put literal text in double quotes", "to-char-patterns");
+        }
+        out += fmt[i] === "%" ? "%%" : fmt[i];
+        i++;
+    }
+    return out;
+}
+/** to_char of a time or a number, by Postgres's template rules (src/duck/to-char.ts): the value's text, the format's */
+function toChar(args, type) {
+    if (args.length !== 2)
+        throw new Unrewritable("to_char() takes a value and a format", "write to_char(value, 'format')", { postgres: "42883" });
+    if (type !== null && [DATE, TIMESTAMP, TIMESTAMPTZ].includes(type))
+        return fn("__mason_to_char_time", [cast(args[0], ["varchar"]), cast(args[1], ["varchar"])]);
+    if (type !== null && (INTEGERS.has(type) || FLOATS.has(type) || type === NUMERIC))
+        return fn("__mason_to_char_number", [cast(args[0], ["varchar"]), cast(args[1], ["varchar"])]);
+    throw new Unrewritable("to_char of an interval is not supported by Mason", "format its parts with extract(… from interval), or to_char a timestamp", "to-char-patterns");
+}
+function strptimeFormat(fmt) {
+    const s = constString(fmt);
+    if (s === null)
+        throw new Unrewritable("to_timestamp / to_date with a format that is not a literal is not supported by Mason", "write the format as a string literal", "to-timestamp-format");
+    return translateTemplate(s, true);
+}
+/** Rewrites one statement's raw tree (libpg-query's `stmt`, offsets from `base`) by Postgres's analysis of it. */
+/**
+ * The name Postgres gives a select-list expression that has no AS (FigureColname, parse_target.c): a column's own
+ * name, a function's, `case`, `coalesce`, `array`, `exists`, a cast's argument's name or its type's, and `?column?` for
+ * the rest. DuckDB names them otherwise (`count_star()`, `(1 + 1)`, `CAST(x AS VARCHAR(40))`), so a query reading an
+ * inner query's column by Postgres's name failed there (a review finding: `SELECT s.count FROM (SELECT count(*)
+ * …) s`). Every unnamed target is given this name (`nameTargets`).
+ */
+export function figureColname(n) {
+    const k = kindOf(n), b = bodyOf(n);
+    switch (k) {
+        case "ColumnRef": {
+            const f = (b.fields ?? []);
+            const last = f[f.length - 1];
+            return last !== undefined && kindOf(last) === "String" ? String(bodyOf(last).sval) : "?column?";
+        }
+        case "A_Indirection": {
+            const ind = (b.indirection ?? []);
+            for (let i = ind.length - 1; i >= 0; i--) {
+                if (kindOf(ind[i]) === "String")
+                    return String(bodyOf(ind[i]).sval);
+                if (kindOf(ind[i]) === "A_Star")
+                    break;
+            }
+            return isNode(b.arg) ? figureColname(b.arg) : "?column?";
+        }
+        case "FuncCall": return lastName(b.funcname);
+        case "TypeCast": {
+            const inner = isNode(b.arg) ? figureColname(b.arg) : "?column?";
+            return inner !== "?column?" ? inner : lastName(b.typeName?.names);
+        }
+        case "CollateClause": return isNode(b.arg) ? figureColname(b.arg) : "?column?";
+        case "GroupingFunc": return "grouping";
+        case "SubLink": {
+            if (b.subLinkType === "EXISTS_SUBLINK")
+                return "exists";
+            if (b.subLinkType === "ARRAY_SUBLINK")
+                return "array";
+            if (b.subLinkType !== "EXPR_SUBLINK" || !isNode(b.subselect))
+                return "?column?";
+            const first = (bodyOf(b.subselect).targetList ?? [])[0];
+            return first !== undefined ? (bodyOf(first).name ?? (isNode(bodyOf(first).val) ? figureColname(bodyOf(first).val) : "?column?")) : "?column?";
+        }
+        case "CaseExpr": return "case";
+        case "A_ArrayExpr": return "array";
+        case "RowExpr": return "row";
+        case "CoalesceExpr": return "coalesce";
+        case "MinMaxExpr": return b.op === "IS_GREATEST" ? "greatest" : "least";
+        case "SQLValueFunction": return String(b.op ?? "").replace(/^SVFOP_/, "").replace(/_N$/, "").toLowerCase() || "?column?";
+        case "XmlExpr": return String(b.op ?? "").replace(/^IS_/, "").toLowerCase().replace(/^document$/, "?column?") || "?column?";
+        case "XmlSerialize": return "xmlserialize";
+        case "JsonObjectConstructor": return "json_object";
+        case "JsonArrayConstructor":
+        case "JsonArrayQueryConstructor": return "json_array";
+        case "JsonObjectAgg": return "json_objectagg";
+        case "JsonArrayAgg": return "json_arrayagg";
+        case "JsonParseExpr": return "json";
+        case "JsonScalarExpr": return "json_scalar";
+        case "JsonSerializeExpr": return "json_serialize";
+        case "JsonFuncExpr": return String(b.op ?? "").replace(/^JSON_(.*)_OP$/, "json_$1").toLowerCase() || "?column?";
+        default: return "?column?";
+    }
+}
+/** every select list's unnamed target named as Postgres names it (a star keeps its expansion) */
+function nameTargets(v) {
+    if (Array.isArray(v)) {
+        for (const x of v)
+            nameTargets(x);
+        return;
+    }
+    if (v === null || typeof v !== "object")
+        return;
+    const b = isNode(v) ? bodyOf(v) : v;
+    if (isNode(v) && kindOf(v) === "SelectStmt" || !isNode(v) && Array.isArray(b.targetList)) {
+        for (const t of (b.targetList ?? [])) {
+            const r = bodyOf(t);
+            if (r.name === undefined && isNode(r.val) && !hasStar(r.val))
+                r.name = figureColname(r.val);
+        }
+    }
+    for (const [k, x] of Object.entries(b))
+        nameTargets(armOf(k, x) ?? x);
+}
+export function rewrite(stmt, base, analysis, collation, userTypes = new Map(), rowTypes = new Map(), timeZone = "UTC", enums = { labels: new Map(), arrays: new Map() }, kept = null) {
+    const r = new Rewriter(analysis, base, collation, userTypes, rowTypes, timeZone, enums, kept);
+    const own = JSON.parse(JSON.stringify(stmt));
+    volatileWindows(own);
+    r.adopt(own);
+    nameTargets(own);
+    r.indexShapes(own);
+    const exact = r.exactThrough(own, analysis.fields);
+    const tree = guardFilters(flattenBool(r.walk(own)));
+    return { tree, dropLast: r.excludeRank, exact, clock: r.clock, jsonReads: [...r.jsonReads.values()] };
+}
+/** the functions whose every call is a new value (Postgres's volatile ones Mason answers) */
+const VOLATILE = new Set(["random", "gen_random_uuid", "uuid_generate_v4", "clock_timestamp", "timeofday"]);
+/** A window ordered or partitioned by a volatile function (`row_number() OVER (ORDER BY random())`, a random row per
+ *  group) is refused by name: DuckDB refuses a volatile expression there, and one it takes as deterministic is computed
+ *  once for every row (one value: the order is the input's, never random) */
+function volatileWindows(v) {
+    const calls = (x) => Array.isArray(x) ? x.some(calls) : x !== null && typeof x === "object"
+        && ((isNode(x) && kindOf(x) === "FuncCall" && VOLATILE.has(lastName(bodyOf(x).funcname))) || Object.values(isNode(x) ? bodyOf(x) : x).some(calls));
+    const check = (w) => {
+        if (calls(w.orderClause) || calls(w.partitionClause)) {
+            throw new Unrewritable("a window ordered or partitioned by random() (or another volatile function) is not supported by Mason", "compute it in a subquery and order by its column: SELECT …, row_number() OVER (ORDER BY r) FROM (SELECT *, random() AS r FROM t) AS s", "volatile-window");
+        }
+    };
+    const walk = (x) => {
+        if (Array.isArray(x)) {
+            x.forEach(walk);
+            return;
+        }
+        if (x === null || typeof x !== "object")
+            return;
+        if (isNode(x)) {
+            const b = bodyOf(x);
+            if (kindOf(x) === "FuncCall" && b.over !== undefined && b.over !== null && typeof b.over === "object")
+                check(b.over);
+            if (kindOf(x) === "WindowDef")
+                check(b);
+            Object.values(b).forEach(walk);
+            return;
+        }
+        Object.values(x).forEach(walk);
+    };
+    walk(v);
+}
+/** An AND inside an AND (an OR inside an OR) as one list: a rewrite may make one (a text BETWEEN is two comparisons
+ *  under the collation), the printer writes it without parentheses and the parser reads one flat list back. The same
+ *  statement, by associativity, in three-valued logic too */
+function flattenBool(v) {
+    if (Array.isArray(v))
+        return v.map(flattenBool);
+    if (v === null || typeof v !== "object")
+        return v;
+    const out = Object.fromEntries(Object.entries(v).map(([k, x]) => [k, flattenBool(x)]));
+    if (isNode(v) && kindOf(v) === "BoolExpr") {
+        const b = bodyOf(out);
+        if (b.boolop === "AND_EXPR" || b.boolop === "OR_EXPR") {
+            b.args = (b.args ?? []).flatMap((a) => kindOf(a) === "BoolExpr" && bodyOf(a).boolop === b.boolop ? bodyOf(a).args : [a]);
+        }
+    }
+    return out;
+}
+/** whether a tree holds a node of this kind */
+function holdsKind(v, kind) {
+    if (Array.isArray(v))
+        return v.some((x) => holdsKind(x, kind));
+    if (v === null || typeof v !== "object")
+        return false;
+    if (isNode(v) && kindOf(v) === kind)
+        return true;
+    return Object.values(isNode(v) ? bodyOf(v) : v).some((x) => holdsKind(x, kind));
+}
+/**
+ * AN AGGREGATE'S FILTER GUARDS ITS ARGUMENTS: Postgres evaluates an aggregate's arguments and ORDER BY only on the rows
+ * its FILTER keeps, DuckDB on every row before it filters, so `min(a / b) FILTER (WHERE b <> 0)` raised 22012 where
+ * Postgres answers (the oracle statement of min / max of a quotient). Each argument that reads a column
+ * and is more than the column is read under a CASE of the filter, which DuckDB evaluates only where it holds. A filter
+ * holding a subquery is left as it is (it would run twice), and so is a constant argument (percentile_cont's fraction
+ * must stay one). So is a DISTINCT aggregate: DuckDB holds its ORDER BY to its arguments (42803), and a guarded
+ * collation key no longer matched them (`string_agg(DISTINCT t, ', ') FILTER (…)`, the rerun at cc380e8d) — its
+ * arguments may still raise on a row the filter drops.
+ */
+function guardFilters(v) {
+    if (Array.isArray(v))
+        return v.map(guardFilters);
+    if (v === null || typeof v !== "object")
+        return v;
+    const out = Object.fromEntries(Object.entries(v).map(([k, x]) => [k, guardFilters(x)]));
+    if (!isNode(v) || kindOf(v) !== "FuncCall")
+        return out;
+    const b = bodyOf(out);
+    const filter = b.agg_filter;
+    if (!isNode(filter) || holdsKind(filter, "SubLink") || b.agg_distinct === true)
+        return out;
+    const guard = (a) => kindOf(a) === "ColumnRef" || !holdsKind(a, "ColumnRef") ? a : caseWhen([[structuredClone(filter), a]], null);
+    if (Array.isArray(b.args))
+        b.args = b.args.map(guard);
+    if (Array.isArray(b.agg_order))
+        for (const sort of b.agg_order) {
+            const sb = bodyOf(sort);
+            if (isNode(sb.node))
+                sb.node = guard(sb.node);
+        }
+    return out;
+}
+const isTypeName = (v) => v !== null && typeof v === "object" && !Array.isArray(v) && Array.isArray(v.names) && "typemod" in v;
+/** a type's name as the parser spells it: `bigint` is `pg_catalog.int8` once read */
+const TYPE_ALIAS = { bigint: "int8", integer: "int4", int: "int4", smallint: "int2", real: "float4", double: "float8", "double precision": "float8", boolean: "bool", decimal: "numeric", varchar: "varchar", "character varying": "varchar" };
+const canonicalType = (n) => { const last = (n[n.length - 1] ?? "").toLowerCase(); return TYPE_ALIAS[last] ?? last; };
+/**
+ * THE MASON FUNCTIONS A REWRITTEN TREE CALLS: every `FuncCall` of a `__mason_*` name in it (`fn` builds each, the
+ * stored path's `__mason_json_get` behind its CASE included), sorted, each once. What the plan carries to the executor
+ * (src/duck/plan.ts PlannedSql `functions`), which cancels a statement that calls one through its session and
+ * interrupts one that calls none (src/duck/store.ts "HOW A STATEMENT IS CANCELLED"). Read off the TREE, never the
+ * printed text: a `__mason_` in the text is also a stored path's column or the view of a copy's visible columns
+ * (src/duck/kept-route.ts), which call nothing — read as a call, every `SELECT *` over a copy with a stored path could
+ * no longer be timed out or cancelled (a review finding).
+ */
+export function masonCalls(tree) {
+    const found = new Set();
+    const walk = (n) => {
+        if (Array.isArray(n)) {
+            for (const x of n)
+                walk(x);
+            return;
+        }
+        if (n === null || typeof n !== "object")
+            return;
+        for (const [k, v] of Object.entries(n)) {
+            if (k === "FuncCall" && v !== null && typeof v === "object") {
+                const name = lastName(v.funcname);
+                if (name.startsWith("__mason_"))
+                    found.add(name);
+            }
+            walk(v);
+        }
+    };
+    walk(tree);
+    return [...found].sort();
+}
+/**
+ * The printed statement READ BACK holds the rewritten tree: every field the tree has, equal (offsets aside), where the
+ * parser may add the defaults a built node leaves out (a `location`, `typemod: -1`, `inh: true`). A field the printer
+ * dropped or changed (a `WITH TIES`, an operator) is a difference.
+ */
+export function sameTree(back, tree) { return treeDifference(back, tree) === null; }
+/** where the read-back tree first differs from the rewritten one (a path and both values), or null */
+export function treeDifference(back, tree, at = "$") {
+    const show = (v) => JSON.stringify(v)?.slice(0, 120) ?? String(v);
+    if (isTypeName(tree) && isTypeName(back)) {
+        const { names: _a, ...restTree } = tree, { names: _b, ...restBack } = back;
+        const [t, b] = [canonicalType(names(tree.names)), canonicalType(names(back.names))];
+        return t !== b ? `${at}.names: ${b} where the rewrite has ${t}` : treeDifference(restBack, restTree, at);
+    }
+    if (Array.isArray(tree)) {
+        if (!Array.isArray(back) || back.length !== tree.length)
+            return `${at}: ${show(back)} where the rewrite has ${show(tree)}`;
+        for (let i = 0; i < tree.length; i++) {
+            const d = treeDifference(back[i], tree[i], `${at}[${i}]`);
+            if (d !== null)
+                return d;
+        }
+        return null;
+    }
+    if (tree === null || typeof tree !== "object")
+        return back === tree || (typeof tree === "number" && Number(back) === tree) ? null : `${at}: ${show(back)} where the rewrite has ${show(tree)}`;
+    if (back === null || typeof back !== "object" || Array.isArray(back))
+        return `${at}: ${show(back)} where the rewrite has ${show(tree)}`;
+    for (const [k, v] of Object.entries(tree)) {
+        if (k === "location" || k === "stmt_location" || k === "stmt_len" || /(^|_)list_(start|end)$/.test(k))
+            continue;
+        const d = treeDifference(back[k], v, `${at}.${k}`);
+        if (d !== null)
+            return d;
+    }
+    return null;
+}