@aotter/mantle 0.1.4 → 0.2.0-alpha.1

package/dist/core/sql/allowlist.js

@@ -0,0 +1,705 @@
+import { PG_GRAMMAR } from "../../spec/domain/model/SqlIr.js";
+import { SqlRefusal } from "../../spec/domain/service/SqlRefusal.js";
+import { intervalMicros, parseNumeric } from "../../spec/domain/service/SqlTypes.js";
+/** node type -> the keys it may carry */
+export const KEYS_SRC = {
+    SelectStmt: 'targetList fromClause whereClause groupClause havingClause sortClause limitCount distinctClause valuesLists limitOption op',
+    InsertStmt: 'relation cols selectStmt onConflictClause returningClause override',
+    UpdateStmt: 'relation targetList whereClause returningClause',
+    DeleteStmt: 'relation whereClause returningClause',
+    ReturningClause: 'exprs', ResTarget: 'name val', ColumnRef: 'fields', String: 'sval', A_Star: '',
+    A_Const: 'ival fval sval boolval isnull', A_Expr: 'kind name lexpr rexpr',
+    BoolExpr: 'boolop args', NullTest: 'arg nulltesttype', CaseExpr: 'arg args defresult', CaseWhen: 'expr result',
+    CoalesceExpr: 'args', TypeCast: 'arg typeName', TypeName: 'names typemod typmods',
+    FuncCall: 'funcname args agg_star agg_distinct over funcformat', WindowDef: 'partitionClause orderClause frameOptions',
+    SubLink: 'subLinkType testexpr subselect operName', SortBy: 'node sortby_dir sortby_nulls',
+    RangeVar: 'relname alias inh relpersistence mantle', Alias: 'aliasname', RangeSubselect: 'subquery alias',
+    RangeFunction: 'functions alias', JoinExpr: 'jointype larg rarg quals', List: 'items',
+    OnConflictClause: 'action infer targetList whereClause', InferClause: 'indexElems', IndexElem: 'name ordering nulls_ordering',
+};
+export const KEYS = Object.fromEntries(Object.entries(KEYS_SRC).map(([k, v]) => [k, new Set(v.split(' ').filter(Boolean))]));
+/**
+ * Where a node may sit. The printers print whatever node a slot holds, and the policy rewriter wraps only a `RangeVar` in FROM, so
+ * the type of every child is checked against its slot: a `String` in FROM would print as a table read with no wrapper. A key not
+ * listed here is a scalar (a name, an enum, a flag) and must hold a string, number or boolean, never a node.
+ */
+const EXPR = 'ColumnRef A_Const A_Expr BoolExpr NullTest CaseExpr CoalesceExpr TypeCast FuncCall SubLink MinMaxExpr';
+const FROM = 'RangeVar RangeSubselect RangeFunction JoinExpr';
+const SLOTS_SRC = {
+    'SelectStmt.targetList': 'ResTarget', 'SelectStmt.fromClause': FROM, 'SelectStmt.whereClause': EXPR, 'SelectStmt.havingClause': EXPR,
+    'SelectStmt.groupClause': EXPR, 'SelectStmt.sortClause': 'SortBy', 'SelectStmt.limitCount': EXPR, 'SelectStmt.distinctClause': EXPR,
+    'SelectStmt.valuesLists': 'List', 'SelectStmt>List.items': EXPR,
+    'InsertStmt.cols': 'ResTarget', 'InsertStmt.selectStmt': 'SelectStmt', 'UpdateStmt.targetList': 'ResTarget', 'UpdateStmt.whereClause': EXPR,
+    'DeleteStmt.whereClause': EXPR, 'ReturningClause.exprs': 'ResTarget', 'ResTarget.val': EXPR,
+    'ColumnRef.fields': 'String A_Star', 'A_Expr.name': 'String', 'A_Expr.lexpr': EXPR, 'A_Expr.rexpr': `${EXPR} List`, 'A_Expr>List.items': EXPR,
+    'BoolExpr.args': EXPR, 'NullTest.arg': EXPR, 'CaseExpr.arg': EXPR, 'CaseExpr.args': 'CaseWhen', 'CaseExpr.defresult': EXPR,
+    'CaseWhen.expr': EXPR, 'CaseWhen.result': EXPR, 'CoalesceExpr.args': EXPR, 'TypeCast.arg': EXPR, 'TypeName.names': 'String', 'TypeName.typmods': 'A_Const',
+    'FuncCall.funcname': 'String', 'FuncCall.args': EXPR, 'FuncCall.agg_filter': EXPR, 'FuncCall.agg_order': 'SortBy',
+    'WindowDef.partitionClause': EXPR, 'WindowDef.orderClause': 'SortBy', 'WindowDef.startOffset': EXPR, 'WindowDef.endOffset': EXPR,
+    'SubLink.testexpr': EXPR, 'SubLink.subselect': 'SelectStmt', 'SubLink.operName': 'String', 'SortBy.node': EXPR,
+    'RangeSubselect.subquery': 'SelectStmt', 'RangeFunction.functions': 'List', 'RangeFunction>List.items': 'FuncCall',
+    'JoinExpr.larg': FROM, 'JoinExpr.rarg': FROM, 'JoinExpr.quals': EXPR,
+    'OnConflictClause.targetList': 'ResTarget', 'OnConflictClause.whereClause': EXPR, 'InferClause.indexElems': 'IndexElem',
+    'WithClause.ctes': 'CommonTableExpr', 'CommonTableExpr.ctequery': 'SelectStmt', 'CommonTableExpr.aliascolnames': 'String', 'MinMaxExpr.args': EXPR,
+};
+const SLOTS = new Map(Object.entries(SLOTS_SRC).map(([k, v]) => [k, new Set(v.split(' '))]));
+/** keys (or `Type.key`) whose value is one node with the type key omitted (libpg-query prints nothing for it) */
+export const BARE = { alias: 'Alias', typeName: 'TypeName', infer: 'InferClause', returningClause: 'ReturningClause', relation: 'RangeVar', over: 'WindowDef', onConflictClause: 'OnConflictClause', withClause: 'WithClause', 'SelectStmt.larg': 'SelectStmt', 'SelectStmt.rarg': 'SelectStmt' };
+export const ENUM = {
+    'SelectStmt.op': ['SETOP_NONE'], 'SelectStmt.limitOption': ['LIMIT_OPTION_DEFAULT', 'LIMIT_OPTION_COUNT'],
+    'InsertStmt.override': ['OVERRIDING_NOT_SET'], 'RangeVar.inh': [true], 'RangeVar.relpersistence': ['p'], 'RangeVar.mantle': ['table', 'cte'],
+    'A_Expr.kind': ['AEXPR_OP', 'AEXPR_IN', 'AEXPR_LIKE', 'AEXPR_BETWEEN', 'AEXPR_NOT_BETWEEN', 'AEXPR_DISTINCT', 'AEXPR_NOT_DISTINCT', 'AEXPR_NULLIF'],
+    'BoolExpr.boolop': ['AND_EXPR', 'OR_EXPR', 'NOT_EXPR'], 'NullTest.nulltesttype': ['IS_NULL', 'IS_NOT_NULL'],
+    'SubLink.subLinkType': ['EXISTS_SUBLINK', 'EXPR_SUBLINK', 'ANY_SUBLINK'], 'JoinExpr.jointype': ['JOIN_INNER', 'JOIN_LEFT'],
+    'SortBy.sortby_dir': ['SORTBY_DEFAULT', 'SORTBY_ASC', 'SORTBY_DESC'], 'SortBy.sortby_nulls': ['SORTBY_NULLS_DEFAULT', 'SORTBY_NULLS_FIRST', 'SORTBY_NULLS_LAST'],
+    'FuncCall.funcformat': ['COERCE_EXPLICIT_CALL', 'COERCE_SQL_SYNTAX'],
+    'WindowDef.frameOptions': [1058], // 1058 = the default frame; any frame clause is refused
+    'OnConflictClause.action': ['ONCONFLICT_NOTHING', 'ONCONFLICT_UPDATE'], 'TypeName.typemod': [-1],
+    'IndexElem.ordering': ['SORTBY_DEFAULT'], 'IndexElem.nulls_ordering': ['SORTBY_NULLS_DEFAULT'],
+};
+// LIKE is an AEXPR_LIKE node, checked below; `~~` written as a plain operator prints as itself, which SQLite cannot parse
+const OPS = new Set(['=', '<>', '!=', '<', '>', '<=', '>=', '+', '-', '*', '/', '%', '||', '->>']);
+/** scalar and aggregate functions. `pg_catalog.` is stripped before the lookup. */
+export const FUNCS = new Set([
+    'count', 'sum', 'min', 'max', 'avg', 'json_group_array', 'json_group_object', 'row_number', 'rank',
+    'lower', 'upper', 'length', 'abs', 'round', 'substr', 'replace', 'btrim', 'ltrim', 'rtrim', 'instr', 'typeof', 'hex', // btrim is what PostgreSQL parses trim(x) to
+    'json_extract', 'json_set', 'json_insert', 'json_remove', 'json_array_length',
+    'now', 'auth.uid', 'auth.role', 'date_trunc', 'extract', 'like_escape',
+    'mantle.search', 'mantle.search_rank', 'mantle.near', 'mantle.distance',
+]);
+const WINDOW = new Set(['row_number', 'rank', 'sum', 'count']);
+/** functions that exist only with OVER */
+const WINDOW_ONLY = new Set(['row_number', 'rank', 'dense_rank', 'lag', 'lead', 'first_value', 'last_value']);
+const AGG = new Set(['count', 'sum', 'min', 'max', 'avg', 'json_group_array', 'json_group_object']);
+export const TRUNC_UNITS = new Set(['hour', 'day', 'week', 'month', 'year']);
+export const EXTRACT_FIELDS = new Set(['year', 'month', 'day', 'dow', 'hour']);
+const CAST_TYPES = new Set(['text', 'int4', 'int8', 'float8', 'bool', 'timestamptz', 'date', 'numeric', 'interval']);
+export const MAX_RADIUS_M = 50_000;
+export const MAX_NEAR_K = 100;
+/** The most nodes one program's IR may have. */
+export const MAX_NODES = 2000;
+const BASE_PROFILE = { name: 'base', keys: KEYS, enums: ENUM, ops: OPS, funcs: FUNCS, window: WINDOW, agg: AGG, trunc: TRUNC_UNITS, extract: EXTRACT_FIELDS, casts: CAST_TYPES };
+// ---- ADR-0037 decision 2: the reference profile's additions --------------------------------------------------------------
+const MORE_KEYS = {
+    SelectStmt: 'withClause larg rarg all', WithClause: 'ctes recursive', CommonTableExpr: 'ctename ctequery aliascolnames ctematerialized',
+    RangeSubselect: 'lateral', FuncCall: 'agg_filter agg_order', WindowDef: 'startOffset endOffset', MinMaxExpr: 'op args',
+};
+const MORE_ENUM = {
+    'SelectStmt.op': ['SETOP_UNION', 'SETOP_INTERSECT', 'SETOP_EXCEPT'], 'A_Expr.kind': ['AEXPR_ILIKE'],
+    'CommonTableExpr.ctematerialized': ['CTEMaterializeDefault', 'CTEMaterializeAlways', 'CTEMaterializeNever'], 'MinMaxExpr.op': ['IS_GREATEST', 'IS_LEAST'],
+};
+const MORE_OPS = ['->', '#>', '#>>', '@>', '<@', '?', '?|', '?&', '~', '~*', '!~', '!~*', '~~*', '!~~*'];
+const MORE_WINDOW = ['avg', 'min', 'max', 'lag', 'lead', 'first_value', 'last_value', 'dense_rank'];
+const MORE_AGG = ['string_agg', 'jsonb_agg', 'jsonb_object_agg'];
+const MORE_FUNCS = [...MORE_WINDOW, ...MORE_AGG, 'jsonb_build_object', 'jsonb_build_array', 'jsonb_strip_nulls', 'to_jsonb', 'jsonb_typeof', 'split_part', 'floor', 'ceil', 'sqrt', 'power', 'timezone'];
+/** frame bits a window may not set: GROUPS and every EXCLUDE (PostgreSQL's FRAMEOPTION_* in parsenodes.h) */
+export const FRAME_REFUSED = 0x8 | 0x8000 | 0x10000 | 0x20000;
+const union = (a, b) => new Set([...a, ...b]);
+const REFERENCE_PROFILE = {
+    name: 'reference',
+    keys: Object.fromEntries([...new Set([...Object.keys(KEYS), ...Object.keys(MORE_KEYS)])].map((k) => [k, union(KEYS[k] ?? [], (MORE_KEYS[k] ?? '').split(' ').filter(Boolean))])),
+    // a frame is checked by its bits (check.WindowDef), not as one enum value
+    enums: Object.fromEntries([...new Set([...Object.keys(ENUM), ...Object.keys(MORE_ENUM)])].filter((k) => k !== 'WindowDef.frameOptions').map((k) => [k, [...(ENUM[k] ?? []), ...(MORE_ENUM[k] ?? [])]])),
+    ops: union(OPS, MORE_OPS), funcs: union(FUNCS, MORE_FUNCS), window: union(WINDOW, MORE_WINDOW), agg: union(AGG, MORE_AGG),
+    trunc: union(TRUNC_UNITS, ['minute', 'quarter']), extract: union(EXTRACT_FIELDS, ['minute', 'quarter', 'week', 'isoyear', 'isodow', 'doy', 'epoch']),
+    casts: union(CAST_TYPES, ['jsonb']),
+};
+export const PROFILES = { base: BASE_PROFILE, reference: REFERENCE_PROFILE };
+/**
+ * Names that SQLite rejects unquoted while PostgreSQL's keyword list lets the printer emit them bare.
+ * Measured on local D1 by `cases/deparser.ts` (it fails if this list drifts from the measurement).
+ */
+export const SQLITE_ONLY_KEYWORDS = new Set([
+    'add', 'alter', 'autoincrement', 'commit', 'delete', 'drop', 'escape', 'index', 'insert', 'nothing', 'raise', 'set', 'transaction', 'update',
+]);
+export const SYSTEM = new Set(['version', 'status', 'author_id', 'created_at', 'updated_at']);
+const sv = (list) => list.map((n) => n.String?.sval ?? (n.A_Star ? '*' : no('SQL_UNSUPPORTED', 'a name part that is not an identifier'))).join('.');
+const fname = (n) => sv(n.funcname).replace(/^pg_catalog\./, '');
+function no(code, message, offset, keyword) {
+    throw new SqlRefusal(code, message, offset, keyword);
+}
+/** structural refusals name a key or an enum value; these find the keyword in the source text (the AST carries no location for them) */
+const KEYWORD = {
+    'SelectStmt.withClause': /\bWITH\b/i, 'InsertStmt.withClause': /\bWITH\b/i, 'UpdateStmt.withClause': /\bWITH\b/i, 'DeleteStmt.withClause': /\bWITH\b/i,
+    'SelectStmt.limitOffset': /\bOFFSET\b/i, 'SelectStmt.lockingClause': /\bFOR\s+(NO\s+KEY\s+)?(UPDATE|SHARE|KEY\s+SHARE)\b/i, 'SelectStmt.intoClause': /\bINTO\b/i,
+    'SelectStmt.op': /\b(UNION|INTERSECT|EXCEPT)\b/i, 'UpdateStmt.fromClause': /\bFROM\b/i, 'DeleteStmt.usingClause': /\bUSING\b/i,
+    'JoinExpr.jointype': /\b(RIGHT|FULL)\b/i, 'JoinExpr.isNatural': /\bNATURAL\b/i, 'JoinExpr.usingClause': /\bUSING\b/i,
+    'WindowDef.frameOptions': /\b(ROWS|RANGE|GROUPS)\b/i, 'A_Expr.kind': /\bILIKE\b/i, 'InferClause.conname': /\bON\s+CONSTRAINT\b/i,
+    'SelectStmt.distinctClause': /\bDISTINCT\s+ON\b/i, GroupingSet: /\bGROUPING\s+SETS\b/i,
+};
+/** first source offset found in a subtree, so a refusal about a key can still point somewhere */
+function firstLoc(v) {
+    if (!v || typeof v !== 'object')
+        return undefined;
+    if (typeof v.location === 'number' && v.location >= 0)
+        return v.location;
+    for (const c of Array.isArray(v) ? v : Object.values(v)) {
+        const l = firstLoc(c);
+        if (l !== undefined)
+            return l;
+    }
+    return undefined;
+}
+/** Validate a program of statements under a profile. `stmts` are the `stmt` of each RawStmt; `locs` their offsets (CLI only). */
+export function validateProgram(stmts, ctx, locs = [], profile = BASE_PROFILE) {
+    program(stmts, { ...ctx, p: profile, scope: [] }, locs);
+}
+function program(stmts, ctx, locs) {
+    if (!Array.isArray(stmts) || !stmts.length)
+        no('SQL_SHAPE', 'an empty program');
+    if (ctx.kind === 'view' && (stmts.length !== 1 || !stmts[0].SelectStmt))
+        no('SQL_SHAPE', 'a View is exactly one SELECT', locs[1]);
+    ctx = { ...ctx, known: knownColumns(stmts), cols: ctx.columns ?? schemaColumns(ctx.schemas) };
+    const w = { ctx, budget: { n: 0 } };
+    stmts.forEach((s, i) => {
+        const t = Object.keys(s)[0] ?? '';
+        const at = locs[i] ?? firstLoc(s);
+        if (!['SelectStmt', 'InsertStmt', 'UpdateStmt', 'DeleteStmt'].includes(t))
+            no('SQL_UNSUPPORTED', `statement ${t} is refused`, at);
+        if (t === 'SelectStmt' && ctx.kind !== 'view')
+            no('SQL_SHAPE', 'a Procedure statement is a write', at);
+        if (t !== 'SelectStmt' && ctx.kind === 'view')
+            no('SQL_SHAPE', 'a View is one SELECT', at);
+        walk(t, s[t], w, [t], at);
+    });
+    if (ctx.public)
+        publishedJoin(stmts, ctx);
+}
+/** every node of a tree with the given key, at any depth */
+function* find(v, key) {
+    if (!v || typeof v !== 'object')
+        return;
+    for (const [k, c] of Object.entries(v)) {
+        if (k === key)
+            yield c;
+        yield* find(c, key);
+    }
+}
+/** What every program checked against these Schemas reads off them: computed once per plan by a caller that checks many. */
+export function schemaColumns(schemas) {
+    const known = new Set();
+    const scopes = new Set();
+    const types = new Map();
+    for (const s of Object.values(schemas)) {
+        if (typeof s.scope === 'string')
+            scopes.add(s.scope.toLowerCase());
+        for (const [f, t] of Object.entries(s.fields)) {
+            (t === 'geo' ? [f, `${f}_lat`, `${f}_lng`] : [f]).forEach((c) => known.add(c));
+            types.set(f, types.has(f) && types.get(f) !== t ? null : t); // null: two Schemas disagree
+        }
+    }
+    return { known, scopes, types: new Map([...types].filter((e) => e[1] !== null)) };
+}
+/**
+ * Every name a column may have beyond the declared fields (`SchemaColumns.known`, a geo field also as _lat and _lng): `id`, the
+ * system columns, json_each's, relation names and aliases, and every output name the program gives (ORDER BY and outer queries
+ * read them). A name outside both is a typo. Not per relation: a column of another table passes here.
+ */
+function knownColumns(stmts) {
+    const known = new Set(['id', 'key', 'value', 'type', 'atom', 'parent', 'fullkey', 'path', ...SYSTEM]);
+    for (const r of find(stmts, 'ResTarget'))
+        if (r.name)
+            known.add(String(r.name).toLowerCase());
+    for (const r of find(stmts, 'RangeVar'))
+        [r.relname, r.alias?.aliasname].forEach((a) => a && known.add(a.toLowerCase())); // mantle.search(<alias>, ...) names a relation
+    for (const c of find(stmts, 'CommonTableExpr'))
+        [c.ctename, ...(c.aliascolnames ?? []).map((x) => x.String?.sval)].forEach((a) => a && known.add(String(a).toLowerCase()));
+    return known;
+}
+/** ADR-0034 decision 8: a public View that joins a non-publishing Schema must tie it to a publishing one in a JOIN ... ON. */
+function publishedJoin(stmts, ctx) {
+    // a CTE reference is not a relation: the Schemas its body reads are found where they are
+    const rels = [...find(stmts, 'RangeVar')].filter((r) => r.mantle !== 'cte').map((r) => ({
+        alias: (r.alias?.aliasname ?? r.relname).toLowerCase(),
+        publishing: !!ctx.schemas[r.relname.toLowerCase()]?.publishing,
+    }));
+    if (!rels.some((r) => r.publishing))
+        return;
+    const ons = [...find(stmts, 'JoinExpr')].map((j) => new Set([...find(j.quals, 'ColumnRef')].filter((c) => c.fields.length === 2).map((c) => c.fields[0].String.sval.toLowerCase())));
+    for (const r of rels)
+        if (!r.publishing && !ons.some((o) => o.has(r.alias) && rels.some((p) => p.publishing && o.has(p.alias))))
+            no('SQL_RELATION', `${r.alias} has no published state: a public View must join it to a publishing Schema in a JOIN ... ON`);
+}
+/** A node's keys and enum values against the profile. */
+function shape(type, node, w, here) {
+    const keys = w.ctx.p.keys[type] ?? no('SQL_UNSUPPORTED', `${type} is not in the subset`, here, KEYWORD[type]);
+    for (const [k, v] of Object.entries(node)) {
+        if (k === 'location' || k === 'rexpr_list_start' || k === 'rexpr_list_end')
+            continue; // source positions, not structure
+        if (!keys.has(k))
+            no('SQL_UNSUPPORTED', `${type}.${k} is not in the subset`, firstLoc(v) ?? here, KEYWORD[`${type}.${k}`]);
+        const e = w.ctx.p.enums[`${type}.${k}`];
+        if (e && !e.includes(v))
+            no('SQL_UNSUPPORTED', `${type}.${k} = ${JSON.stringify(v)} is refused`, firstLoc(node) ?? here, KEYWORD[`${type}.${k}`]);
+    }
+    if (type === 'String' && node.sval !== undefined && typeof node.sval !== 'string')
+        no('SQL_SHAPE', 'a name is a string', here);
+    if (type === 'A_Const' && !constant(node))
+        no('SQL_UNSUPPORTED', 'a literal is one integer, numeric, string, boolean or NULL', firstLoc(node) ?? here);
+}
+/**
+ * A literal's value is printed as it is, so its type is checked here: the walker never descends into a literal, and a plan
+ * that reaches the runtime is untrusted. libpg-query omits a zero, a false and an empty string (`{ ival: {} }`).
+ */
+function constant(node) {
+    const own = Object.keys(node).filter((k) => k !== 'location');
+    if (own.length !== 1)
+        return false;
+    const [k] = own;
+    const v = node[k];
+    const only = (key, ok) => !!v && typeof v === 'object' && Object.keys(v).every((x) => x === key) && (!(key in v) || ok(v[key]));
+    switch (k) {
+        case 'ival': return only('ival', Number.isSafeInteger);
+        // the parser's Float: a point or exponent, or an integer past int32 (smaller ones are ival); never a sign the printers would
+        // print as `+2`, which SQLite reads as a column position in ORDER BY
+        // (one split of the digits, so the match is linear; and no longer than any number the parser writes)
+        case 'fval': return only('fval', (x) => typeof x === 'string' && x.length <= 64 && /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:[eE][-+]?\d+)?$/.test(x) && (/[.eE]/.test(x) || Math.abs(Number(x)) >= 2 ** 31));
+        case 'sval': return only('sval', (x) => typeof x === 'string');
+        case 'boolval': return only('boolval', (x) => typeof x === 'boolean');
+        case 'isnull': return v === true;
+        default: return false;
+    }
+}
+/** Runs `f` with these CTE names in scope. */
+function withScope(w, names, f) {
+    w.ctx.scope.push(new Set(names));
+    try {
+        f();
+    }
+    finally {
+        w.ctx.scope.pop();
+    }
+}
+function walk(type, node, w, path, loc) {
+    if (++w.budget.n > MAX_NODES)
+        no('SQL_SHAPE', 'statement too large', loc);
+    const here = typeof node.location === 'number' ? node.location : loc;
+    shape(type, node, w, here);
+    try {
+        check[type]?.(node, w.ctx, path, here);
+    }
+    catch (e) {
+        if (e instanceof SqlRefusal && e.offset === undefined && !e.keyword)
+            e.offset = here; // a helper (interval, numeric) refused without knowing where
+        throw e;
+    }
+    // PostgreSQL's CTE scope: a body sees its earlier siblings (every sibling under RECURSIVE); the SELECT's body sees them all
+    const wc = type === 'SelectStmt' ? node.withClause : undefined;
+    const names = (wc?.ctes ?? []).map((x) => String(x.CommonTableExpr?.ctename));
+    if (wc) {
+        shape('WithClause', wc, w, here);
+        if (wc.recursive !== undefined && typeof wc.recursive !== 'boolean')
+            no('SQL_UNSUPPORTED', 'WithClause.recursive is a flag', here);
+        (wc.ctes ?? []).forEach((x, j) => withScope(w, wc.recursive ? names : names.slice(0, j), () => child(x, w, [...path, 'WithClause'], 'ctes', here)));
+    }
+    // the Schema relations this statement reads directly, by alias: what a column reference in it can name (`jsonCompare`)
+    const rels = type === 'SelectStmt' || type === 'UpdateStmt' || type === 'DeleteStmt' ? relationsOf(node) : undefined;
+    if (rels)
+        (w.ctx.rels ??= []).push(rels);
+    try {
+        withScope(w, names, () => {
+            for (const [k, v] of Object.entries(node)) {
+                if (type === 'A_Const' || k === 'location' || k === 'rexpr_list_start' || k === 'rexpr_list_end' || (wc && k === 'withClause'))
+                    continue;
+                const bare = BARE[`${type}.${k}`] ?? BARE[k];
+                const slot = bare || SLOTS.has(`${type}.${k}`) || (type === 'List' && k === 'items');
+                if (!slot) {
+                    if (v !== null && typeof v === 'object')
+                        no('SQL_UNSUPPORTED', `${type}.${k} is a value, not a node`, here);
+                    continue;
+                }
+                if (v === null || typeof v !== 'object')
+                    no('SQL_UNSUPPORTED', `${type}.${k} holds a node`, here);
+                if (bare)
+                    walk(bare, v, w, [...path, bare], here);
+                else if (Array.isArray(v))
+                    v.forEach((c) => child(c, w, path, k, here));
+                else
+                    child(v, w, path, k, here);
+            }
+        });
+    }
+    finally {
+        if (rels)
+            w.ctx.rels.pop();
+    }
+}
+/** A statement's own Schema relations (FROM, its joins, an UPDATE or DELETE target), by alias; never a subquery or CTE. */
+function relationsOf(node) {
+    const out = new Map();
+    const add = (n) => {
+        if (n?.JoinExpr)
+            return (add(n.JoinExpr.larg), add(n.JoinExpr.rarg));
+        const v = n?.RangeVar ?? n;
+        if (v?.mantle === 'table')
+            out.set(String(v.alias?.aliasname ?? v.relname).toLowerCase(), String(v.relname).toLowerCase());
+    };
+    for (const f of node.fromClause ?? [])
+        add(f);
+    add(node.relation);
+    return out;
+}
+function child(c, w, path, k, loc) {
+    const keys = Object.keys(c);
+    if (!keys.length) {
+        if (k === 'distinctClause' || (k === 'items' && path.at(-2) === 'RangeFunction'))
+            return; // `DISTINCT` is [{}]; a json_each coldeflist slot is {}
+        no('SQL_UNSUPPORTED', `an empty node in ${k}`, loc);
+    }
+    if (keys.length !== 1 || c[keys[0]] === null || typeof c[keys[0]] !== 'object')
+        no('SQL_UNSUPPORTED', 'a malformed node', loc);
+    const parent = path.at(-1);
+    const allowed = SLOTS.get(parent === 'List' ? `${path.at(-2)}>List.${k}` : `${parent}.${k}`);
+    if (w.ctx.p.keys[keys[0]] && !allowed?.has(keys[0]))
+        no('SQL_SHAPE', `${keys[0]} cannot stand in ${parent}.${k}`, loc); // an unknown type is shape()'s refusal
+    walk(keys[0], c[keys[0]], w, [...path, keys[0]], loc);
+}
+/** A cast's type: `t` or `pg_catalog.t`, read as the lowerings and printers read it (the last name part). */
+const castType = (typeName) => {
+    const names = (typeName?.names ?? []).map((n) => n?.String?.sval);
+    const ok = names.every((x) => typeof x === 'string' && /^[a-z_][a-z0-9_]*$/.test(x)) && (names.length === 1 || (names.length === 2 && names[0] === 'pg_catalog'));
+    if (!ok)
+        no('SQL_TYPE', `a cast names one type: ${JSON.stringify(names)}`);
+    return names.at(-1);
+};
+const isConst = (n) => !!n?.A_Const;
+const isInputRef = (n) => n?.ColumnRef?.fields?.length === 2 && n.ColumnRef.fields[0].String?.sval === 'input';
+const check = {
+    RangeVar: (n, ctx, _p, at) => {
+        // the parser folds an unquoted name and the CLI writes only lower case: an `ARTICLES` would be one Schema to the checks and
+        // another to what keys hooks and publishing by the folded name, so a relation (a Schema or a CTE reference) is lower case
+        if (typeof n.relname !== 'string' || n.relname !== n.relname.toLowerCase())
+            no('SQL_RELATION', `${JSON.stringify(n.relname)}: a relation is named in lower case`, at);
+        const name = n.relname;
+        if (name.startsWith('_mantle') || name === 'input' || name === 'auth')
+            no('SQL_RELATION', `${name} is not a declared Schema`, at);
+        const reference = ctx.p.name === 'reference';
+        // a `cte` tag is honored only for a CTE in scope here (the runtime never trusts an IR's tags); base has no WITH at all
+        if (n.mantle === 'cte') {
+            if (reference && ctx.scope.some((s) => s.has(n.relname)))
+                return;
+            no('SQL_RELATION', `${name}: a cte reference is not defined in scope`, at);
+        }
+        if (!ctx.schemas[name])
+            no('SQL_RELATION', `${name} is not a declared Schema`, at);
+        if (n.mantle !== undefined && n.mantle !== 'table')
+            no('SQL_RELATION', `${name}: relation not name-resolved`, at);
+        if (n.alias && ['input', 'auth', 'excluded'].includes(n.alias.aliasname))
+            no('SQL_RELATION', `${n.alias.aliasname} is a reserved alias`, at);
+        if (!reference)
+            for (const ident of [name, n.alias?.aliasname])
+                if (ident && SQLITE_ONLY_KEYWORDS.has(ident))
+                    no('SQL_UNSUPPORTED', `${ident} is an SQLite keyword: the printer would not quote it`, at);
+    },
+    ColumnRef: (n, ctx, _p, at) => {
+        const f = sv(n.fields), last = f.split('.').pop().toLowerCase();
+        if (n.fields.length > 2)
+            no('SQL_COLUMN', `${f}: at most alias.column`, at);
+        if (['rowid', 'oid', '_rowid_', '_rid'].includes(last))
+            no('SQL_COLUMN', `${last} is not addressable`, at);
+        if (ctx.cols.scopes.has(last))
+            no('SQL_COLUMN', `${f}: the scope column is not addressable`, at);
+        if (f.startsWith('input.') && !(last in ctx.inputs))
+            no('SQL_COLUMN', `${f} is not a declared input`, at);
+        if (ctx.p.name === 'base' && SQLITE_ONLY_KEYWORDS.has(last))
+            no('SQL_UNSUPPORTED', `${last} is an SQLite keyword: the printer would not quote it`, at);
+        if (last !== '*' && !f.startsWith('input.') && !ctx.known.has(last) && !ctx.cols.known.has(last))
+            no('SQL_COLUMN', `${f} is not a declared field`, at);
+    },
+    FuncCall: (n, ctx, path, at) => {
+        const f = fname(n);
+        if (f === 'json_each') {
+            if (path.at(-2) !== 'List' || path.at(-3) !== 'RangeFunction')
+                no('SQL_FUNCTION', 'json_each is only allowed in FROM', at);
+            return;
+        }
+        if (!ctx.p.funcs.has(f))
+            no('SQL_FUNCTION', `function ${f} is not on the allowlist`, at);
+        if (n.over && (ctx.kind !== 'view' || !ctx.p.window.has(f)))
+            no('SQL_FUNCTION', `window function ${f} is refused here`, at);
+        if (!n.over && WINDOW_ONLY.has(f))
+            no('SQL_FUNCTION', `${f}() is a window function: it needs OVER (...)`, at);
+        if ((f === 'lag' || f === 'lead') && n.args?.[1] && n.args[1].A_Const?.ival === undefined)
+            no('SQL_FUNCTION', `${f}'s offset is an integer literal`, at);
+        if ((n.agg_filter || n.agg_order) && !ctx.p.agg.has(f))
+            no('SQL_FUNCTION', `FILTER and ORDER BY belong to an aggregate, and ${f} is not one`, at);
+        const args = n.args ?? [];
+        const str = (a) => a?.A_Const?.sval?.sval;
+        switch (f) {
+            case 'like_escape':
+                if (path.at(-2) !== 'A_Expr' || args.length !== 2)
+                    no('SQL_FUNCTION', 'like_escape is only the ESCAPE of a LIKE', at);
+                break;
+            case 'date_trunc':
+                if (args.length !== 2 || !ctx.p.trunc.has(str(args[0]) ?? ''))
+                    no('SQL_TYPE', `date_trunc takes ${[...ctx.p.trunc].join(', ')} as a literal first argument`, at);
+                break;
+            case 'extract':
+                if (args.length !== 2 || !ctx.p.extract.has(str(args[0]) ?? ''))
+                    no('SQL_TYPE', `extract takes ${[...ctx.p.extract].join(', ')}`, at);
+                break;
+            case 'now':
+            case 'auth.uid':
+            case 'auth.role':
+                if (args.length)
+                    no('SQL_FUNCTION', `${f}() takes no arguments`, at);
+                break;
+            case 'mantle.search':
+            case 'mantle.search_rank':
+                if (args.length !== (f === 'mantle.search' ? 2 : 1) || args[0]?.ColumnRef?.fields?.length !== 1)
+                    no('SQL_FUNCTION', f === 'mantle.search' ? 'mantle.search(<alias>, <query>)' : 'mantle.search_rank(<alias>)', at);
+                break;
+            case 'mantle.near':
+            case 'mantle.distance': {
+                const want = f === 'mantle.near' ? 4 : 3;
+                const fld = args[0]?.ColumnRef?.fields;
+                if (args.length !== want || fld?.length !== 2)
+                    no('SQL_FUNCTION', `${f}(<alias>.<geo field>, lat, lng${f === 'mantle.near' ? ', meters' : ''})`, at);
+                for (const a of args.slice(1, 3))
+                    if (!isConst(a) && !isInputRef(a))
+                        no('SQL_FUNCTION', `${f}: latitude and longitude are a literal or input.<name>`, at);
+                if (f === 'mantle.near') {
+                    const m = args[3]?.A_Const?.ival?.ival ?? args[3]?.A_Const?.fval?.fval;
+                    if (m === undefined)
+                        no('SQL_FUNCTION', 'mantle.near() needs a literal radius in meters', at);
+                    if (Number(m) > MAX_RADIUS_M || Number(m) <= 0)
+                        no('SQL_FUNCTION', `mantle.near() radius is at most ${MAX_RADIUS_M} m`, at);
+                }
+                break;
+            }
+        }
+        if (ctx.p.agg.has(f) && n.args?.length === 0 && !n.agg_star)
+            no('SQL_FUNCTION', `${f} needs an argument`, at);
+        // the printers print these as written: `*` is count(*) only, DISTINCT one argument of an aggregate outside a window
+        if (n.agg_star && (f !== 'count' || args.length))
+            no('SQL_FUNCTION', `${f}(*) is refused: only count(*)`, at);
+        if (n.agg_distinct && (!ctx.p.agg.has(f) || args.length !== 1 || n.over))
+            no('SQL_FUNCTION', `DISTINCT is one argument of an aggregate, outside a window`, at);
+    },
+    A_Expr: (n, ctx, _p, at) => {
+        const op = sv(n.name);
+        // the printer joins what it is given: a missing operand or a one-bound BETWEEN would bind the policy predicate appended after it
+        const items = n.rexpr?.List?.items;
+        const range = n.kind === 'AEXPR_BETWEEN' || n.kind === 'AEXPR_NOT_BETWEEN';
+        if (!n.rexpr || (!n.lexpr && !(n.kind === 'AEXPR_OP' && (op === '-' || op === '+'))) || (range && items?.length !== 2) || (n.kind === 'AEXPR_IN' && !items?.length) || (!range && n.kind !== 'AEXPR_IN' && n.rexpr.List))
+            no('SQL_SHAPE', `a malformed ${op} expression`, at);
+        // the parser folds a sign into its number (`-2` is ival -2): a sign over a number constant is a resealed IR, and PostgreSQL
+        // folds `- -2` back into 2, a column position in ORDER BY and GROUP BY
+        if (n.kind === 'AEXPR_OP' && !n.lexpr && (op === '-' || op === '+') && (n.rexpr?.A_Const?.ival !== undefined || n.rexpr?.A_Const?.fval !== undefined))
+            no('SQL_SHAPE', `a sign over a number is that number: write ${op === '-' ? 'the negative constant' : 'the constant'}`, at);
+        if (ctx.p.name === 'base')
+            bareLiteralCompare(n, ctx, at); // PostgreSQL casts the literal to the column's type
+        jsonCompare(n, ctx, at);
+        if (n.kind === 'AEXPR_OP' && !ctx.p.ops.has(op))
+            no('SQL_UNSUPPORTED', `operator ${op} is refused`, at);
+        if (n.kind === 'AEXPR_IN' && !['=', '<>'].includes(op))
+            no('SQL_UNSUPPORTED', 'a bad IN', at);
+        if (n.kind === 'AEXPR_LIKE' && !['~~', '!~~'].includes(op))
+            no('SQL_UNSUPPORTED', 'ILIKE and regular expressions are refused', at, /\bILIKE\b/i);
+        if (n.kind === 'AEXPR_ILIKE' && !['~~*', '!~~*'].includes(op))
+            no('SQL_UNSUPPORTED', 'a bad ILIKE', at);
+        const esc = (x) => !!x?.FuncCall && fname(x.FuncCall) === 'like_escape';
+        if (esc(n.lexpr) || (esc(n.rexpr) && n.kind !== 'AEXPR_LIKE'))
+            no('SQL_FUNCTION', 'like_escape is only the ESCAPE of a LIKE', at);
+    },
+    TypeCast: (n, ctx, _p, at) => {
+        const t = castType(n.typeName);
+        if (!ctx.p.casts.has(t))
+            no('SQL_TYPE', `CAST to ${t} is refused`, at);
+        const lit = n.arg?.A_Const;
+        // the literal-only rules exist because SQLite truncates and stores time and decimals as integers; PostgreSQL casts any value
+        const base = ctx.p.name === 'base';
+        if (base && (t === 'int4' || t === 'int8') && !(lit?.ival || /^\s*-?\d+\s*$/.test(lit?.sval?.sval ?? 'x')))
+            no('SQL_TYPE', `CAST to ${t} takes an integer literal: SQLite truncates toward zero where PostgreSQL rounds. Write round(x)`, at);
+        // a type modifier is numeric's precision and scale, or one interval field (hour, minute, second) that truncates nothing; D1
+        // encodes nothing else (timestamptz(0) rounds on PostgreSQL, interval '90 minutes' hour truncates to an hour there)
+        // (intervalMicros reads a bare number in the field's unit and refuses any other field; one unit of the field divides the value)
+        const mods = n.typeName.typmods ?? [];
+        const typmod = mods[0]?.A_Const?.ival?.ival;
+        if (mods.length && t !== 'numeric' && !(t === 'interval' && mods.length === 1 && intervalMicros(lit?.sval?.sval ?? 'x', typmod) % intervalMicros('1', typmod) === 0))
+            no('SQL_TYPE', `CAST to ${t} takes no type modifier here, or one that truncates nothing`, at);
+        if (t === 'interval') {
+            if (!lit?.sval)
+                no('SQL_TYPE', 'an interval is a literal such as interval \'36 hours\'', at);
+            intervalMicros(lit.sval.sval, n.typeName.typmods?.[0]?.A_Const?.ival?.ival); // throws SQL_TYPE for calendar units
+        }
+        if (base && (t === 'timestamptz' || t === 'date') && !lit?.sval)
+            no('SQL_TYPE', `CAST to ${t} takes a literal (the compiler folds it to its integer encoding)`, at);
+        if (t === 'numeric') {
+            const [p, s] = (n.typeName.typmods ?? []).map((m) => m.A_Const?.ival?.ival ?? 0);
+            if (p === undefined)
+                no('SQL_TYPE', 'numeric needs (precision, scale)', at);
+            parseNumeric(`numeric(${p}, ${s})`);
+            if (base && !lit)
+                no('SQL_TYPE', 'CAST to numeric takes a literal: numeric columns are integer counts of the smallest unit', at);
+        }
+    },
+    ResTarget: (n, ctx, _p, at) => {
+        if (ctx.p.name === 'base' && n.name && SQLITE_ONLY_KEYWORDS.has(n.name))
+            no('SQL_UNSUPPORTED', `${n.name} is an SQLite keyword: the printer would not quote it`, at);
+    },
+    SubLink: (n, _c, _p, at) => {
+        if (n.subLinkType === 'ANY_SUBLINK' && n.operName && sv(n.operName) !== '=')
+            no('SQL_UNSUPPORTED', 'only IN (subquery)', at);
+    },
+    JoinExpr: (n, _c, _p, at) => {
+        if (!n.quals)
+            no('SQL_SHAPE', 'a JOIN needs ON', at, /\bCROSS\s+JOIN\b|\bJOIN\b/i);
+    },
+    RangeFunction: (n, _c, _p, at) => {
+        const fs = n.functions;
+        if (fs.length !== 1 || fs[0]?.List?.items?.length !== 2 || sv(fs[0].List.items[0].FuncCall?.funcname ?? []) !== 'json_each')
+            no('SQL_FUNCTION', 'only json_each() is allowed in FROM', at);
+        if (fs[0].List.items[0].FuncCall.args?.length !== 1)
+            no('SQL_FUNCTION', 'json_each takes one argument', at);
+    },
+    RangeSubselect: (n, _c, _p, at) => {
+        if (!n.alias)
+            no('SQL_SHAPE', 'a subquery in FROM needs an alias', at);
+    },
+    CommonTableExpr: (n, _c, _p, at) => {
+        if (!n.ctequery?.SelectStmt)
+            no('SQL_SHAPE', 'a CTE body is a SELECT: a write inside WITH is refused', at);
+        // the printer writes a CTE's name and its column names unquoted: each is a plain lower-case identifier
+        for (const name of [n.ctename, ...(n.aliascolnames ?? []).map((c) => c?.String?.sval)])
+            if (typeof name !== 'string' || !/^[a-z_][a-z0-9_]*$/.test(name))
+                no('SQL_SHAPE', `a CTE name is lower case, a plain identifier: ${JSON.stringify(name)}`, at);
+    },
+    BoolExpr: (n, _c, _p, at) => {
+        const k = (n.args ?? []).length;
+        if (n.boolop === 'NOT_EXPR' ? k !== 1 : k < 1)
+            no('SQL_SHAPE', `a malformed ${n.boolop}`, at);
+    },
+    WindowDef: (n, _c, _p, at) => {
+        if (n.frameOptions & FRAME_REFUSED)
+            no('SQL_UNSUPPORTED', 'GROUPS frames and EXCLUDE are refused', at, /\b(GROUPS|EXCLUDE)\b/i);
+        // an offset is a literal: rows as an integer, a RANGE over time as an interval literal
+        for (const o of [n.startOffset, n.endOffset])
+            if (o && !(o.A_Const?.ival !== undefined || (o.TypeCast?.arg?.A_Const?.sval && castType(o.TypeCast.typeName) === 'interval')))
+                no('SQL_SHAPE', 'a frame offset is a literal: an integer, or an interval such as interval \'6 days\'', at);
+    },
+    SelectStmt: (n, ctx, path, at) => {
+        const reference = ctx.p.name === 'reference';
+        // Core pages and orders a View's own SELECT (ADR-0037 decision 2), so what reshapes rows lives in a CTE or a subquery
+        const top = ctx.kind === 'view' && path.length === 1;
+        const distinctOn = !!n.distinctClause && (n.distinctClause.length !== 1 || Object.keys(n.distinctClause[0]).length > 0);
+        if (n.op && n.op !== 'SETOP_NONE' && top)
+            no('SQL_SHAPE', 'UNION, INTERSECT and EXCEPT go inside a WITH or a subquery: Core pages the View\'s own SELECT', at, /\b(UNION|INTERSECT|EXCEPT)\b/i);
+        if (n.limitCount && !n.sortClause)
+            no('SQL_SHAPE', 'LIMIT needs an ORDER BY', firstLoc(n.limitCount) ?? at);
+        if (distinctOn && (!reference || top))
+            no(reference ? 'SQL_SHAPE' : 'SQL_UNSUPPORTED', reference ? 'DISTINCT ON goes inside a WITH or a subquery: Core pages the View\'s own SELECT' : 'DISTINCT ON is refused', at, /\bDISTINCT\s+ON\b/i);
+        if (n.distinctClause && !distinctOn && n.sortClause)
+            no('SQL_SHAPE', 'DISTINCT with ORDER BY is refused: the appended id key would change what is distinct', at);
+        if (n.valuesLists && (path.at(-2) !== 'InsertStmt' || n.valuesLists.length !== 1))
+            no('SQL_SHAPE', 'VALUES is one row, in INSERT only', firstLoc(n.valuesLists) ?? at);
+        if ((n.fromClause ?? []).slice(1).some((f) => !f.RangeFunction && !(reference && f.RangeSubselect?.lateral)))
+            no('SQL_SHAPE', reference ? 'a comma join is refused (except json_each and LATERAL)' : 'a comma join is refused (except json_each)', at);
+        // mantle.near()/mantle.distance(): a query ordered by mantle.distance() needs a LIMIT of at most MAX_NEAR_K
+        const byDistance = JSON.stringify(n.sortClause ?? []).includes('"distance"');
+        if (byDistance) {
+            const k = n.limitCount?.A_Const?.ival?.ival;
+            if (k === undefined || k > MAX_NEAR_K)
+                no('SQL_SHAPE', `a query ordered by mantle.distance() needs a literal LIMIT of at most ${MAX_NEAR_K}`, firstLoc(n.sortClause) ?? at);
+        }
+    },
+    UpdateStmt: (n, ctx) => writeList(n.targetList, ctx, n.relation, false),
+    InsertStmt: (n, ctx, _p, at) => {
+        writeList(n.cols ?? no('SQL_WRITE', 'INSERT needs a column list', at), ctx, n.relation, true, n.selectStmt?.SelectStmt?.valuesLists?.[0]?.List?.items);
+        if (n.onConflictClause?.action === 'ONCONFLICT_UPDATE')
+            writeList(n.onConflictClause.targetList, ctx, n.relation, false);
+    },
+};
+/** Columns stored as integers that PostgreSQL compares with a string literal by casting it: the system timestamps and these types. */
+const STORED_AS_NUMBER = new Set(['timestamptz', 'date', 'bool']);
+const SYSTEM_TIMES = new Set(['created_at', 'updated_at']);
+/** The type a column name has in every Schema that declares it, or undefined when none does or they disagree. */
+function columnType(ctx, name) {
+    if (SYSTEM_TIMES.has(name))
+        return 'timestamptz';
+    return ctx.cols.types.get(name);
+}
+/**
+ * PostgreSQL reads `startsAt > '2020-01-01'` by casting the literal to the column's type; SQLite compares the stored integer with
+ * text and the condition is silently false. A bare string literal against a date-time, date or boolean column is refused.
+ */
+function bareLiteralCompare(n, ctx, at) {
+    const compares = n.kind === 'AEXPR_OP' ? ['=', '<>', '!=', '<', '>', '<=', '>='].includes(sv(n.name)) : ['AEXPR_IN', 'AEXPR_BETWEEN', 'AEXPR_NOT_BETWEEN', 'AEXPR_DISTINCT', 'AEXPR_NOT_DISTINCT'].includes(n.kind);
+    if (!compares)
+        return;
+    const typeOf = (x) => { const f = x?.ColumnRef?.fields; const name = f?.at(-1)?.String?.sval; return name && !(f.length === 2 && f[0].String?.sval === 'input') ? columnType(ctx, String(name).toLowerCase()) : undefined; };
+    const literals = (x) => (x?.List ? x.List.items.flatMap(literals) : x?.A_Const?.sval ? [x.A_Const.sval.sval] : []);
+    for (const [colSide, other] of [[n.lexpr, n.rexpr], [n.rexpr, n.lexpr]]) {
+        const type = typeOf(colSide);
+        if (!type || !STORED_AS_NUMBER.has(type))
+            continue;
+        const text = literals(other)[0];
+        if (text !== undefined)
+            no('SQL_TYPE', `'${text}' is text and the column is ${type}, which is stored as a number: ${type === 'bool' ? 'write true or false' : `write CAST('${text}' AS ${type})`}, or bind it as an input`, at);
+    }
+}
+/**
+ * A json field compares as its stored text on SQLite and as jsonb on PostgreSQL (no jsonb < integer): either way not as the value
+ * the author meant, so a comparison of one is refused on every dialect. The field is the statement's own Schema column: named
+ * through its alias, or bare when exactly one of its Schema relations declares it.
+ */
+function jsonCompare(n, ctx, at) {
+    const compares = n.kind === 'AEXPR_OP' ? ['=', '<>', '!=', '<', '>', '<=', '>='].includes(sv(n.name)) : ['AEXPR_IN', 'AEXPR_BETWEEN', 'AEXPR_NOT_BETWEEN', 'AEXPR_DISTINCT', 'AEXPR_NOT_DISTINCT'].includes(n.kind);
+    const rels = ctx.rels?.at(-1);
+    if (!compares || !rels)
+        return;
+    for (const side of [n.lexpr, n.rexpr]) {
+        const f = side?.ColumnRef?.fields;
+        if (!f || f.length > 2 || !f.every((x) => x.String))
+            continue;
+        const name = String(f.at(-1).String.sval).toLowerCase();
+        const schemas = f.length === 2 ? [rels.get(String(f[0].String.sval).toLowerCase())].filter((s) => !!s)
+            : [...new Set(rels.values())].filter((s) => Object.hasOwn(ctx.schemas[s]?.fields ?? {}, name));
+        if (schemas.length === 1 && ctx.schemas[schemas[0]]?.fields[name] === 'json')
+            no('SQL_TYPE', `${f.at(-1).String.sval} is json: compare a value read with ->> (and CAST), or declare the field with one scalar type`, at);
+    }
+}
+/** A write may not name the scope field or a system column; `id` is never writable on update, and on a scoped Schema never on insert. */
+function writeList(list, ctx, rel, insert, values) {
+    const s = ctx.schemas[rel.relname.toLowerCase()];
+    for (const [i, { ResTarget: r }] of list.entries()) {
+        const at = firstLoc(r) ?? firstLoc(rel);
+        const name = String(r.name).toLowerCase();
+        const scopedId = insert && name === 'id' && s?.scope;
+        if (name === s?.scope?.toLowerCase() || SYSTEM.has(name) || (!insert && name === 'id') || scopedId)
+            no('SQL_WRITE', `${r.name} is filled by Mantle and cannot be written${scopedId ? ' (a scoped Schema generates its ids)' : ''}`, at);
+        const cols = Object.entries(s?.fields ?? {}).flatMap(([f, t]) => (t === 'geo' ? [`${f}_lat`, `${f}_lng`] : [f]));
+        if (name !== 'id' && !cols.includes(name))
+            no('SQL_WRITE', `${rel.relname} has no field ${r.name}`, at);
+        // a bare text literal in a column stored as a number: SQLite's STRICT table would fail it at run time, so refuse it here
+        const type = s?.fields[name];
+        const literal = (insert ? values?.[i] : r.val)?.A_Const?.sval?.sval;
+        if (ctx.p.name === 'base' && literal !== undefined && type && !['text', 'json'].includes(type) && !/^-?\d+(\.\d+)?$/.test(literal))
+            no('SQL_TYPE', `'${literal}' is text and ${r.name} is ${type}: write CAST('${literal}' AS ${type === 'integer' ? 'int8' : type === 'real' ? 'float8' : type}), or bind it as an input`, at);
+    }
+}
+/** A `SqlRefusal` as a `SqlDiagnostic`, without a source position (the runtime has no source text). */
+function refusalToDiagnostic(e) {
+    return { code: e.code, message: e.message };
+}
+/**
+ * The runtime's check of a plan's IR: the grammar version, then the exact allowlist.
+ * Returns no diagnostics when the plan is acceptable, otherwise the first refusal.
+ * Also the check for IR built by handler code. Never throws for bad input.
+ */
+export function validateIr(plan, ctx, profile = BASE_PROFILE) {
+    try {
+        if (plan?.grammar !== PG_GRAMMAR)
+            no("SQL_UNSUPPORTED", `plan was compiled with PostgreSQL grammar ${plan?.grammar}, this runtime reads ${PG_GRAMMAR}`);
+        validateProgram(plan.stmts, ctx, [], profile);
+        return [];
+    }
+    catch (e) {
+        if (e instanceof SqlRefusal)
+            return [refusalToDiagnostic(e)];
+        // Hand-built IR can be malformed in ways the allowlist does not anticipate (null, wrong types).
+        // Refusing is the only safe answer.
+        return [{ code: "SQL_UNSUPPORTED", message: `malformed IR: ${e instanceof Error ? e.message : String(e)}` }];
+    }
+}
+//# sourceMappingURL=allowlist.js.map