@sqlanvil/cli 1.27.1 → 1.28.0

package/bundle.js

@@ -50646,7 +50646,7 @@ function collectEvaluationQueries(queryOrAction, concatenate, queryModifier = (q
         .filter(validationQuery => !!validationQuery.query);
 }
 
-const version = "1.27.1";
+const version = "1.28.0";
 const dataformVersion = "3.0.61";
 
 async function build(compiledGraph, runConfig, dbadapter) {
@@ -51496,13 +51496,17 @@ function renderDeclarationSqlx(opts) {
         lines.push(`  schema: ${quote(opts.schema)},`);
     }
     lines.push(`  name: ${quote(opts.name)},`);
-    const typeLines = opts.columns.map(function (c) { return `    ${keyToken(c.name)}: ${quote(c.type)}`; });
+    const typeLines = opts.columns.map(function (c) {
+        return `    ${keyToken(c.name.toLowerCase())}: ${quote(c.type)}`;
+    });
     const described = opts.columns.filter(function (c) { return !!c.description; });
     lines.push(`  columnTypes: {`);
     lines.push(typeLines.join(",\n"));
     lines.push(described.length > 0 ? `  },` : `  }`);
     if (described.length > 0) {
-        const descLines = described.map(function (c) { return `    ${keyToken(c.name)}: ${quote(c.description)}`; });
+        const descLines = described.map(function (c) {
+            return `    ${keyToken(c.name.toLowerCase())}: ${quote(c.description)}`;
+        });
         lines.push(`  columns: {`);
         lines.push(descLines.join(",\n"));
         lines.push(`  }`);
@@ -52586,18 +52590,34 @@ class PostgresDbAdapter {
 
 const MAX_PARAMS_PER_INSERT = 60000;
 const quoteIdent = (id) => `"${String(id).replace(/"/g, '""')}"`;
+function foldColumns(columnTypes, target) {
+    var _a;
+    const cols = Object.keys(columnTypes).map(source => ({ source, target: source.toLowerCase() }));
+    const byFolded = new Map();
+    for (const c of cols) {
+        byFolded.set(c.target, [...((_a = byFolded.get(c.target)) !== null && _a !== void 0 ? _a : []), c.source]);
+    }
+    for (const [folded, sources] of byFolded) {
+        if (sources.length > 1) {
+            throw new Error(`Source ${target.schema}.${target.name} has columns that differ only in case ` +
+                `(${sources.join(", ")}); PostgreSQL folds them to the same identifier "${folded}". ` +
+                `Rename one at the source, or select them with distinct aliases.`);
+        }
+    }
+    return cols;
+}
 async function createPgLoader(args) {
     var _a;
     const { target, columnTypes } = args;
-    const cols = Object.keys(columnTypes);
     const coerce = args.coerce || ((v) => (v === undefined ? null : v));
+    const cols = foldColumns(columnTypes, target);
     const pg = await PostgresDbAdapter.create(args.pg, {
         concurrencyLimit: 1,
         disableSslForTestsOnly: args.disableSslForTestsOnly
     });
     try {
         const qualified = `${quoteIdent(target.schema)}.${quoteIdent(target.name)}`;
-        const colDefs = cols.map(c => `${quoteIdent(c)} ${columnTypes[c]}`).join(", ");
+        const colDefs = cols.map(c => `${quoteIdent(c.target)} ${columnTypes[c.source]}`).join(", ");
         await pg.execute(`create schema if not exists ${quoteIdent(target.schema)}`);
         const { rows: existing } = await pg.execute(`select c.relkind from pg_class c join pg_namespace n on n.oid = c.relnamespace ` +
             `where n.nspname = $1 and c.relname = $2`, { params: [target.schema, target.name] });
@@ -52617,7 +52637,7 @@ async function createPgLoader(args) {
         await pg.close();
         throw e;
     }
-    const colIdents = cols.map(quoteIdent).join(", ");
+    const colIdents = cols.map(c => quoteIdent(c.target)).join(", ");
     const qualified = `${quoteIdent(target.schema)}.${quoteIdent(target.name)}`;
     const batchRows = Math.max(1, Math.min(1000, Math.floor(MAX_PARAMS_PER_INSERT / cols.length)));
     return {
@@ -52628,7 +52648,7 @@ async function createPgLoader(args) {
                 const params = [];
                 const tuples = batch.map((row, r) => {
                     const placeholders = cols.map((c, ci) => `$${r * cols.length + ci + 1}`);
-                    cols.forEach(c => params.push(coerce(row[c])));
+                    cols.forEach(c => params.push(coerce(row[c.source])));
                     return `(${placeholders.join(", ")})`;
                 });
                 await pg.execute(`insert into ${qualified} (${colIdents}) values ${tuples.join(", ")}`, {
@@ -54280,12 +54300,18 @@ async function writeParquet(rows, outPath, columns) {
         await fs__namespace.remove(tmp).catch(() => undefined);
     }
 }
+const normalizeValue = (v) => typeof v === "bigint"
+    ? v >= BigInt(Number.MIN_SAFE_INTEGER) && v <= BigInt(Number.MAX_SAFE_INTEGER)
+        ? Number(v)
+        : v.toString()
+    : v;
 async function queryParquet(sql, views) {
     return withDuckdb(async (conn) => {
         for (const view of views) {
             await runAsync(conn, `create view ${view.name} as select * from read_parquet('${view.glob}')`);
         }
-        return allAsync(conn, sql);
+        const rows = await allAsync(conn, sql);
+        return rows.map((row) => Object.fromEntries(Object.entries(row).map(([k, v]) => [k, normalizeValue(v)])));
     });
 }
 
@@ -54487,6 +54513,399 @@ ${columnRows || '<tr><td colspan="3" class="meta">No documented columns.</td></t
 `;
 }
 
+function tokenize(sql) {
+    const tokens = [];
+    let i = 0;
+    const push = (kind, start, end, value) => tokens.push({ kind, start, end, text: sql.slice(start, end), value });
+    while (i < sql.length) {
+        const ch = sql[i];
+        if (/\s/.test(ch)) {
+            const start = i;
+            while (i < sql.length && /\s/.test(sql[i]))
+                i++;
+            push("whitespace", start, i);
+            continue;
+        }
+        if (ch === "$" && sql[i + 1] === "{") {
+            const start = i;
+            let depth = 0;
+            for (; i < sql.length; i++) {
+                if (sql[i] === "{")
+                    depth++;
+                else if (sql[i] === "}" && --depth === 0) {
+                    i++;
+                    break;
+                }
+            }
+            push("template", start, i);
+            continue;
+        }
+        if (ch === "-" && sql[i + 1] === "-") {
+            const start = i;
+            while (i < sql.length && sql[i] !== "\n")
+                i++;
+            push("comment", start, i);
+            continue;
+        }
+        if (ch === "#") {
+            const start = i;
+            while (i < sql.length && sql[i] !== "\n")
+                i++;
+            push("comment", start, i);
+            continue;
+        }
+        if (ch === "/" && sql[i + 1] === "*") {
+            const start = i;
+            i += 2;
+            while (i < sql.length && !(sql[i] === "*" && sql[i + 1] === "/"))
+                i++;
+            i = Math.min(sql.length, i + 2);
+            push("comment", start, i);
+            continue;
+        }
+        const rawPrefix = (ch === "r" || ch === "R") && (sql[i + 1] === "'" || sql[i + 1] === '"');
+        if (ch === "'" || ch === '"' || rawPrefix) {
+            const start = i;
+            if (rawPrefix)
+                i++;
+            const quote = sql[i];
+            i++;
+            for (; i < sql.length; i++) {
+                if (sql[i] !== quote)
+                    continue;
+                if (quote === "'" && sql[i + 1] === "'") {
+                    i++;
+                    continue;
+                }
+                i++;
+                break;
+            }
+            const raw = sql.slice(start, i);
+            const inner = raw.slice(rawPrefix ? 2 : 1, raw.length - (raw.endsWith(quote) ? 1 : 0));
+            push(quote === '"' ? "quoted-ident" : "string", start, i, inner);
+            continue;
+        }
+        if (ch === "`") {
+            const start = i;
+            i++;
+            while (i < sql.length && sql[i] !== "`")
+                i++;
+            i = Math.min(sql.length, i + 1);
+            push("backtick-ident", start, i, sql.slice(start + 1, i - 1));
+            continue;
+        }
+        if (/[0-9]/.test(ch)) {
+            const start = i;
+            while (i < sql.length && /[0-9._eE]/.test(sql[i]))
+                i++;
+            push("number", start, i);
+            continue;
+        }
+        if (/[A-Za-z_]/.test(ch)) {
+            const start = i;
+            while (i < sql.length && /[A-Za-z0-9_$]/.test(sql[i]))
+                i++;
+            push("word", start, i);
+            continue;
+        }
+        push("punct", i, i + 1);
+        i++;
+    }
+    return tokens;
+}
+function significant(tokens) {
+    return tokens.filter(t => t.kind !== "whitespace" && t.kind !== "comment");
+}
+function isWord(t, ...words) {
+    return (!!t && t.kind === "word" && words.some(w => t.text.toLowerCase() === w.toLowerCase()));
+}
+function matchBracket(toks, open) {
+    var _a;
+    const openCh = (_a = toks[open]) === null || _a === void 0 ? void 0 : _a.text;
+    const closeCh = openCh === "(" ? ")" : openCh === "[" ? "]" : null;
+    if (!closeCh)
+        return -1;
+    let depth = 0;
+    for (let i = open; i < toks.length; i++) {
+        if (toks[i].text === openCh)
+            depth++;
+        else if (toks[i].text === closeCh && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+const CLAUSE_ENDS = ["where", "group", "order", "having", "window", "limit", "qualify", "union", "intersect", "except"];
+function selectScopes(toks) {
+    const scopes = [];
+    for (let i = 0; i < toks.length; i++) {
+        if (!isWord(toks[i], "select"))
+            continue;
+        let depth = 0;
+        let from = -1;
+        let listEnd = -1;
+        let end = toks.length;
+        for (let j = i + 1; j < toks.length; j++) {
+            const t = toks[j];
+            if (t.text === "(" || t.text === "[")
+                depth++;
+            else if (t.text === ")" || t.text === "]") {
+                if (depth === 0) {
+                    end = j;
+                    break;
+                }
+                depth--;
+            }
+            else if (depth === 0 && t.kind === "word") {
+                const w = t.text.toLowerCase();
+                if (w === "from" && from === -1) {
+                    from = j;
+                    listEnd = j;
+                }
+                else if (CLAUSE_ENDS.includes(w)) {
+                    if (w === "except" && from === -1)
+                        continue;
+                    end = j;
+                    break;
+                }
+            }
+            else if (depth === 0 && t.text === ";") {
+                end = j;
+                break;
+            }
+        }
+        if (listEnd === -1)
+            listEnd = end;
+        scopes.push({
+            select: i,
+            listStart: i + 1,
+            listEnd,
+            from,
+            fromStart: from === -1 ? -1 : from + 1,
+            fromEnd: from === -1 ? -1 : end,
+        });
+    }
+    return scopes;
+}
+function splitOnCommas(toks, start, end) {
+    const out = [];
+    let depth = 0;
+    const stop = Math.min(end, toks.length);
+    let from = Math.max(0, start);
+    for (let i = from; i < stop; i++) {
+        const t = toks[i].text;
+        if (t === "(" || t === "[")
+            depth++;
+        else if (t === ")" || t === "]")
+            depth--;
+        else if (t === "," && depth === 0) {
+            out.push([from, i]);
+            from = i + 1;
+        }
+    }
+    if (from < stop)
+        out.push([from, stop]);
+    return out;
+}
+const JOIN_NOISE = new Set([
+    "on", "using", "left", "right", "inner", "full", "cross", "outer", "join", "lateral", "natural",
+]);
+function relationsIn(toks, start, end) {
+    var _a, _b, _c;
+    const rels = [];
+    let i = start;
+    while (i < end) {
+        if (i > start && !isWord(toks[i - 1], "from", "join")) {
+            i++;
+            continue;
+        }
+        let j = i;
+        let subquery = false;
+        const parts = [];
+        if (((_a = toks[j]) === null || _a === void 0 ? void 0 : _a.text) === "(") {
+            const close = matchBracket(toks, j);
+            if (close < 0)
+                break;
+            subquery = true;
+            parts.push(...toks.slice(j, close + 1));
+            j = close + 1;
+        }
+        else {
+            while (j < end &&
+                (toks[j].kind === "template" ||
+                    toks[j].kind === "word" ||
+                    toks[j].kind === "quoted-ident" ||
+                    toks[j].kind === "backtick-ident" ||
+                    toks[j].text === ".")) {
+                if (isWord(toks[j], "as"))
+                    break;
+                if (toks[j].kind === "word" && JOIN_NOISE.has(toks[j].text.toLowerCase()))
+                    break;
+                parts.push(toks[j]);
+                j++;
+            }
+        }
+        if (!parts.length) {
+            i++;
+            continue;
+        }
+        let alias;
+        let k = j;
+        if (isWord(toks[k], "as"))
+            k++;
+        if (((_b = toks[k]) === null || _b === void 0 ? void 0 : _b.kind) === "word" && !JOIN_NOISE.has(toks[k].text.toLowerCase())) {
+            alias = toks[k].text.toLowerCase();
+            k++;
+        }
+        else {
+            const last = [...parts].reverse().find(p => p.kind === "word" || p.kind === "quoted-ident");
+            if (last && !subquery)
+                alias = ((_c = last.value) !== null && _c !== void 0 ? _c : last.text).toLowerCase();
+        }
+        rels.push({ tokens: parts, alias, subquery });
+        i = Math.max(k, j);
+    }
+    return rels;
+}
+
+function findStructArrays(file, source) {
+    var _a, _b, _c, _d, _e, _f;
+    const toks = significant(tokenize(source));
+    const found = [];
+    for (let i = 0; i < toks.length; i++) {
+        if (!isWord(toks[i], "array") || ((_a = toks[i + 1]) === null || _a === void 0 ? void 0 : _a.text) !== "(")
+            continue;
+        const close = matchBracket(toks, i + 1);
+        if (close < 0)
+            continue;
+        if (!isWord(toks[i + 2], "select") || !isWord(toks[i + 3], "as") || !isWord(toks[i + 4], "struct")) {
+            continue;
+        }
+        const inner = toks.slice(i + 5, close);
+        const innerSql = inner.map(t => t.text).join(" ");
+        const innerToks = significant(tokenize(`select ${innerSql}`));
+        const [scope] = selectScopes(innerToks);
+        const fields = [];
+        if (scope) {
+            for (const [s, e] of splitOnCommas(innerToks, scope.listStart, scope.listEnd)) {
+                const item = innerToks.slice(s, e);
+                const last = item[item.length - 1];
+                fields.push(((_c = (_b = last === null || last === void 0 ? void 0 : last.value) !== null && _b !== void 0 ? _b : last === null || last === void 0 ? void 0 : last.text) !== null && _c !== void 0 ? _c : "").replace(/^"|"$/g, ""));
+            }
+        }
+        const rels = scope && scope.from !== -1 ? relationsIn(innerToks, scope.fromStart, scope.fromEnd) : [];
+        const source_ = (_e = (_d = rels[0]) === null || _d === void 0 ? void 0 : _d.tokens.map(t => t.text).join("")) !== null && _e !== void 0 ? _e : "";
+        let correlation;
+        const whereIdx = innerToks.findIndex(t => isWord(t, "where"));
+        if (whereIdx !== -1) {
+            const eq = innerToks.findIndex((t, k) => k > whereIdx && t.text === "=");
+            const left = innerToks.slice(Math.max(whereIdx + 1, eq - 3), eq);
+            const right = innerToks.slice(eq + 1, eq + 4);
+            const tail = (parts) => {
+                var _a;
+                const words = parts.filter(t => t.kind === "word" || t.kind === "quoted-ident");
+                return words.length ? ((_a = words[words.length - 1].value) !== null && _a !== void 0 ? _a : words[words.length - 1].text) : "";
+            };
+            if (eq !== -1)
+                correlation = { sourceColumn: tail(left), parentColumn: tail(right) };
+        }
+        let end = toks[close].end;
+        let column = "";
+        if (isWord(toks[close + 1], "as") && toks[close + 2]) {
+            column = ((_f = toks[close + 2].value) !== null && _f !== void 0 ? _f : toks[close + 2].text).replace(/^"|"$/g, "");
+            end = toks[close + 2].end;
+        }
+        found.push({
+            file,
+            line: source.slice(0, toks[i].start).split("\n").length,
+            column,
+            fields,
+            source: source_,
+            correlation,
+            start: toks[i].start,
+            end,
+        });
+    }
+    return found;
+}
+function suggestedSql(site) {
+    var _a, _b, _c, _d, _e, _f;
+    const fields = site.fields.length ? site.fields : ["…"];
+    const key = (_b = (_a = site.correlation) === null || _a === void 0 ? void 0 : _a.sourceColumn) !== null && _b !== void 0 ? _b : "<parent key>";
+    const parentKey = (_d = (_c = site.correlation) === null || _c === void 0 ? void 0 : _c.parentColumn) !== null && _d !== void 0 ? _d : "<parent key>";
+    const src = site.source || "<source relation>";
+    if (site.strategy === "collapse" && site.consumers.length) {
+        const [k, v] = [(_e = fields[0]) !== null && _e !== void 0 ? _e : "key", (_f = fields[1]) !== null && _f !== void 0 ? _f : "value"];
+        return [
+            `-- Drop the \`${site.column}\` column from this action entirely, and have each reader`,
+            `-- pivot ${src} directly. A consumer that today reads:`,
+            `--`,
+            `--   (select any_value(${v}) from unnest(${site.column}) where ${k} = '<name>')`,
+            `--`,
+            `-- becomes, selecting from ${src} grouped by ${parentKey}:`,
+            ``,
+            `max(${v}) filter (where ${k} = '<name>') as <name>`,
+        ].join("\n");
+    }
+    if (site.strategy === "collapse") {
+        return [
+            `-- Nothing reads \`${site.column}\`. Confirm that, then delete the column — porting an`,
+            `-- unused array costs a model change for no consumer.`,
+        ].join("\n");
+    }
+    if (site.strategy === "child-table") {
+        const cols = fields.map(f => `  ${f}`).join(",\n");
+        return [
+            `-- A new action holding the rows, keyed by the parent — this IS what the array was:`,
+            ``,
+            `config { type: "view" }`,
+            ``,
+            `select`,
+            `  ${key} as ${parentKey},`,
+            cols,
+            `from \${ref("${src.replace(/^\$\{ref\(["']|["']\)\}$/g, "")}")}`,
+            ``,
+            `-- Then drop \`${site.column}\` from the parent and have readers join instead:`,
+            `--   join \${ref("<this new action>")} c on c.${parentKey} = p.${parentKey}`,
+        ].join("\n");
+    }
+    const pairs = fields.map(f => `'${f}', ${f}`).join(", ");
+    return [
+        `-- Fallback. Keeps the shape but pushes a document model into a relational warehouse:`,
+        ``,
+        `(select jsonb_agg(jsonb_build_object(${pairs})) from ${src} …) as ${site.column}`,
+        ``,
+        `-- Readers then need jsonb_array_elements(...) and ->> instead of UNNEST.`,
+    ].join("\n");
+}
+function chooseStrategies(sites, files) {
+    return sites.map(site => {
+        const consumers = [];
+        for (const f of files) {
+            if (f.file === site.file || !site.column)
+                continue;
+            const toks = significant(tokenize(f.source));
+            const uses = toks
+                .map((t, i) => ({ t, i }))
+                .filter(({ t }) => t.kind === "word" && t.text.toLowerCase() === site.column.toLowerCase());
+            if (!uses.length)
+                continue;
+            const unnestOnly = uses.every(({ i }) => { var _a; return isWord(toks[i - 2], "unnest") && ((_a = toks[i - 1]) === null || _a === void 0 ? void 0 : _a.text) === "("; });
+            consumers.push({ file: f.file, unnestOnly });
+        }
+        const readers = consumers.length;
+        if (readers && consumers.every(c => c.unnestOnly)) {
+            return Object.assign(Object.assign({}, site), { consumers, strategy: "collapse", rationale: `every read of \`${site.column}\` is an UNNEST (${readers} file(s)), so the array is a ` +
+                    `round trip — read ${site.source || "the source"} directly and drop the array` });
+        }
+        if (!readers) {
+            return Object.assign(Object.assign({}, site), { consumers, strategy: "collapse", rationale: `nothing in the project reads \`${site.column}\` — confirm it is unused, then drop it ` +
+                    `rather than porting it` });
+        }
+        return Object.assign(Object.assign({}, site), { consumers, strategy: "child-table", rationale: `\`${site.column}\` is read in ${readers} file(s) and not only via UNNEST, so it needs to ` +
+                `exist as a relation: a child table keyed by the parent, joined back` });
+    });
+}
+
 function containsPath(parent, child) {
     const rel = path__namespace.relative(parent, child);
     return rel === "" || (!rel.startsWith("..") && !path__namespace.isAbsolute(rel));
@@ -54617,6 +55036,192 @@ function parseSqlxConfig(body) {
         description: str("description", body),
     };
 }
+const CLASS_META = {
+    qualify: {
+        title: "QUALIFY clause",
+        severity: "blocks-compile",
+        owner: "mechanical",
+        postgres: "wrap the query and filter on the window function in an outer WHERE",
+        why: "PostgreSQL has no QUALIFY; the window result must be computed in a subquery first.",
+    },
+    struct: {
+        title: "STRUCT / ARRAY of STRUCT",
+        severity: "blocks-compile",
+        owner: "needs-decision",
+        postgres: "a child table joined back, jsonb, or eliminate the array entirely",
+        why: "An array of structs IS a one-to-many relationship. A child table is usually the better " +
+            "model, and where the array is only ever UNNESTed straight back into a pivot it can be " +
+            "dropped altogether — but which of the three is right depends on what reads it.",
+    },
+    unnest: {
+        title: "UNNEST",
+        severity: "blocks-compile",
+        owner: "needs-decision",
+        postgres: "cross join unnest(array) — but only for arrays of scalars",
+        why: "PostgreSQL's unnest takes arrays only, so an UNNEST over structs depends on how the STRUCT above is resolved.",
+    },
+    "array-type": {
+        title: "ARRAY<T> type syntax",
+        severity: "blocks-compile",
+        owner: "mechanical",
+        postgres: "T[]",
+    },
+    "parse-date": {
+        title: "PARSE_DATE / PARSE_TIMESTAMP",
+        severity: "fails-at-run",
+        owner: "mechanical",
+        postgres: "to_date / to_timestamp, with the format tokens translated",
+        why: "The format tokens differ (%B %Y → 'Month YYYY'). A wrong token does not fail the " +
+            "statement — it fails on the rows that do not match, so verify against real data.",
+    },
+    "format-date": {
+        title: "FORMAT_DATE / FORMAT_TIMESTAMP",
+        severity: "fails-at-run",
+        owner: "mechanical",
+        postgres: "to_char, with the format tokens translated",
+    },
+    "date-diff-unit": {
+        title: "DATE_DIFF with an unhandled unit",
+        severity: "blocks-compile",
+        owner: "mechanical",
+        postgres: "date subtraction, or EXTRACT(EPOCH FROM …) scaled to the unit",
+        why: "DAY and HOUR are converted automatically; other units need the right arithmetic per unit.",
+    },
+    "pseudo-column": {
+        title: "BigQuery pseudo-column",
+        severity: "blocks-compile",
+        owner: "needs-decision",
+        why: "_TABLE_SUFFIX / _PARTITIONTIME have no PostgreSQL analogue; the model usually needs restructuring.",
+    },
+    "export-data": {
+        title: "EXPORT DATA statement",
+        severity: "blocks-compile",
+        owner: "mechanical",
+        postgres: 'a sqlanvil `type: "export"` action',
+    },
+    scripting: {
+        title: "BigQuery scripting (EXECUTE IMMEDIATE)",
+        severity: "blocks-compile",
+        owner: "needs-decision",
+        postgres: "a PL/pgSQL DO block, or an operations action",
+        why: "Dynamic SQL rarely ports mechanically — the shape of the rewrite depends on what it is generating.",
+    },
+    "generate-uuid": {
+        title: "GENERATE_UUID()",
+        severity: "blocks-compile",
+        owner: "mechanical",
+        postgres: "gen_random_uuid()",
+    },
+    "group-by-all": {
+        title: "GROUP BY ALL",
+        severity: "blocks-compile",
+        owner: "mechanical",
+        postgres: "`sqlanvil migrate-fix` rewrites it as ordinals (group by 1, 2, 5)",
+        why: "Window functions must be excluded as well as aggregates — PostgreSQL rejects them in " +
+            "GROUP BY, and an aggregate followed by OVER is a window function, not an aggregate.",
+    },
+    "star-except": {
+        title: "SELECT * EXCEPT (…)",
+        severity: "blocks-compile",
+        owner: "mechanical",
+        postgres: "`sqlanvil migrate-fix` expands it, once introspect has scaffolded the columns",
+        why: "The column list comes from the source relation — a declaration's columnTypes, or another " +
+            "action's select list resolved recursively. Enumerating also means a column added upstream " +
+            "will no longer appear automatically.",
+    },
+    "not-enforced": {
+        title: "NOT ENFORCED constraint (translated, left commented)",
+        severity: "changes-meaning",
+        owner: "needs-decision",
+        postgres: "the constraint is written out above, commented",
+        why: "BigQuery never checked these. Enforcing them may fail on data that has never been " +
+            "validated; dropping them loses the declared model. Enable per table, deliberately.",
+    },
+};
+function analyseStructArrays(report, outDir) {
+    const files = report.files
+        .filter(f => f.file.endsWith(".sqlx"))
+        .map(f => {
+        try {
+            return { file: f.file, source: fs__namespace$1.readFileSync(path__namespace.join(outDir, f.file), "utf8") };
+        }
+        catch (_a) {
+            return null;
+        }
+    })
+        .filter((f) => f !== null);
+    const raw = files.flatMap(f => findStructArrays(f.file, f.source));
+    if (!raw.length)
+        return;
+    const sites = chooseStrategies(raw, files);
+    report.todo = report.todo.filter(t => t.id !== "struct");
+    const meta = CLASS_META.struct;
+    report.todo.push({
+        id: "struct",
+        title: meta.title,
+        count: sites.length,
+        severity: meta.severity,
+        owner: meta.owner,
+        postgres: "per site below — collapse, a child table, or jsonb",
+        why: meta.why,
+        sql: sites.map(s => ({
+            file: s.file,
+            line: s.line,
+            note: `${s.strategy} — ${s.rationale}`,
+            sql: suggestedSql(s),
+        })),
+        locations: sites.map(s => ({ file: s.file, lines: [s.line] })),
+    });
+}
+function buildTriage(report) {
+    var _a, _b, _c, _d, _e, _f, _g, _h;
+    const todo = new Map();
+    const applied = new Map();
+    for (const file of report.files) {
+        for (const f of (_a = file.findings) !== null && _a !== void 0 ? _a : []) {
+            const id = (_b = f.class) !== null && _b !== void 0 ? _b : classIdFor(f.note);
+            const meta = CLASS_META[id];
+            if (f.kind === "rewrite") {
+                const seen = (_c = applied.get(id)) !== null && _c !== void 0 ? _c : { id, title: (_d = meta === null || meta === void 0 ? void 0 : meta.title) !== null && _d !== void 0 ? _d : f.note, count: 0 };
+                seen.count++;
+                applied.set(id, seen);
+                if (!meta || meta.owner !== "needs-decision")
+                    continue;
+            }
+            const entry = (_e = todo.get(id)) !== null && _e !== void 0 ? _e : {
+                id,
+                title: (_f = meta === null || meta === void 0 ? void 0 : meta.title) !== null && _f !== void 0 ? _f : f.note,
+                count: 0,
+                severity: (_g = meta === null || meta === void 0 ? void 0 : meta.severity) !== null && _g !== void 0 ? _g : "blocks-compile",
+                owner: (_h = meta === null || meta === void 0 ? void 0 : meta.owner) !== null && _h !== void 0 ? _h : "mechanical",
+                postgres: meta === null || meta === void 0 ? void 0 : meta.postgres,
+                why: meta === null || meta === void 0 ? void 0 : meta.why,
+                locations: [],
+            };
+            entry.count++;
+            const loc = entry.locations.find(l => l.file === file.file);
+            if (loc)
+                loc.lines.push(f.line);
+            else
+                entry.locations.push({ file: file.file, lines: [f.line] });
+            todo.set(id, entry);
+        }
+    }
+    const rank = {
+        "changes-meaning": 0,
+        "fails-at-run": 1,
+        "blocks-compile": 2,
+    };
+    report.todo = [...todo.values()].sort((a, b) => rank[a.severity] - rank[b.severity] || b.count - a.count);
+    report.applied = [...applied.values()].sort((a, b) => b.count - a.count);
+}
+function classIdFor(note) {
+    return note
+        .slice(0, 40)
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-|-$/g, "");
+}
 const GLOBAL_RULES = [
     {
         pattern: /\bdataform\.projectConfig\b/g,
@@ -54626,12 +55231,6 @@ const GLOBAL_RULES = [
     },
 ];
 const SQL_RULES = [
-    {
-        pattern: /\bSAFE_CAST\s*\(/g,
-        replacement: "CAST(",
-        kind: "rewrite",
-        note: "SAFE_CAST → CAST — Postgres CAST raises on bad input; verify the data or guard it",
-    },
     {
         pattern: /\bCURRENT_DATE\s*\(\s*\)/g,
         replacement: "CURRENT_DATE",
@@ -54644,32 +55243,50 @@ const SQL_RULES = [
         note: "CURRENT_DATE('<tz>') — Postgres: (CURRENT_TIMESTAMP AT TIME ZONE '<tz>')::date",
     },
     {
-        pattern: /\bSAFE_DIVIDE\s*\(/g,
+        pattern: /\*\s*except\s*\(/gi,
         kind: "flag",
-        note: "SAFE_DIVIDE(a, b) — Postgres: a / NULLIF(b, 0)",
+        note: "SELECT * EXCEPT — run `sqlanvil migrate-fix` after introspect to expand it",
+        id: "star-except",
     },
     {
-        pattern: /\bSAFE_OFFSET\s*\(/g,
+        pattern: /\bGROUP\s+BY\s+ALL\b/gi,
         kind: "flag",
-        note: "array[SAFE_OFFSET(n)] — Postgres arrays are 1-based; use (split_part / arr[n+1])",
+        note: "GROUP BY ALL — run `sqlanvil migrate-fix` after introspect to rewrite it",
+        id: "group-by-all",
     },
-    { pattern: /\bQUALIFY\b/gi, kind: "flag", note: "QUALIFY — rewrite as a subquery/CTE filter on the window function" },
-    { pattern: /\bUNNEST\s*\(/g, kind: "flag", note: "UNNEST — Postgres unnest() works on arrays only (no STRUCT arrays); verify semantics" },
-    { pattern: /\bSTRUCT\s*[(<]/g, kind: "flag", note: "STRUCT — no Postgres equivalent; consider jsonb or a composite type" },
-    { pattern: /\bARRAY\s*</g, kind: "flag", note: "ARRAY<T> type syntax — Postgres uses T[]" },
-    { pattern: /\bFORMAT_DATE\s*\(/g, kind: "flag", note: "FORMAT_DATE → TO_CHAR (different format tokens)" },
-    { pattern: /\bPARSE_DATE\s*\(/g, kind: "flag", note: "PARSE_DATE → TO_DATE (different format tokens)" },
-    { pattern: /\bFORMAT_TIMESTAMP\s*\(/g, kind: "flag", note: "FORMAT_TIMESTAMP → TO_CHAR (different format tokens)" },
+    { pattern: /\bQUALIFY\b/gi, kind: "flag", note: "QUALIFY — rewrite as a subquery/CTE filter on the window function",
+        id: "qualify", },
+    { pattern: /\bUNNEST\s*\(/g, kind: "flag", note: "UNNEST — Postgres unnest() works on arrays only (no STRUCT arrays); verify semantics",
+        id: "unnest", },
+    { pattern: /\bSTRUCT\s*[(<]/g, kind: "flag", note: "STRUCT — no Postgres equivalent; consider jsonb or a composite type",
+        id: "struct", },
+    { pattern: /\bARRAY\s*</g, kind: "flag", note: "ARRAY<T> type syntax — Postgres uses T[]",
+        id: "array-type", },
+    { pattern: /\bFORMAT_DATE\s*\(/g, kind: "flag", note: "FORMAT_DATE → TO_CHAR (different format tokens)",
+        id: "format-date", },
+    { pattern: /\bPARSE_DATE\s*\(/g, kind: "flag", note: "PARSE_DATE → TO_DATE (different format tokens)",
+        id: "parse-date", },
+    { pattern: /\bFORMAT_TIMESTAMP\s*\(/g, kind: "flag", note: "FORMAT_TIMESTAMP → TO_CHAR (different format tokens)",
+        id: "format-date", },
     {
         pattern: /\b(DATE_ADD|DATE_SUB|TIMESTAMP_ADD|TIMESTAMP_SUB|DATETIME_ADD|DATETIME_SUB)\s*\(/g,
         kind: "flag",
         note: "BigQuery date arithmetic — Postgres uses interval arithmetic (x + INTERVAL '1 day')",
     },
-    { pattern: /\bDATE_DIFF\s*\(/g, kind: "flag", note: "DATE_DIFF — Postgres: subtraction / EXTRACT(EPOCH FROM ...) depending on the part" },
-    { pattern: /_PARTITIONTIME|_PARTITIONDATE|_TABLE_SUFFIX/g, kind: "flag", note: "BigQuery pseudo-column has no Postgres equivalent" },
-    { pattern: /\bEXPORT\s+DATA\b/gi, kind: "flag", note: "EXPORT DATA — use a sqlanvil `type: \"export\"` action instead" },
-    { pattern: /\bEXECUTE\s+IMMEDIATE\b/gi, kind: "flag", note: "BigQuery scripting (EXECUTE IMMEDIATE) — rewrite as a PL/pgSQL DO block or operations" },
-    { pattern: /\bGENERATE_UUID\s*\(\s*\)/g, kind: "flag", note: "GENERATE_UUID() → gen_random_uuid()" },
+    { pattern: /\bDATE_DIFF\s*\(/g, kind: "flag", note: "DATE_DIFF — Postgres: subtraction / EXTRACT(EPOCH FROM ...) depending on the part",
+        id: "date-diff-unit", },
+    { pattern: /_PARTITIONTIME|_PARTITIONDATE|_TABLE_SUFFIX/g, kind: "flag", note: "BigQuery pseudo-column has no Postgres equivalent",
+        id: "pseudo-column", },
+    {
+        pattern: /\bEXPORT\s+DATA\b/gi,
+        kind: "flag",
+        note: 'EXPORT DATA — use a sqlanvil `type: "export"` action instead',
+        id: "export-data",
+    },
+    { pattern: /\bEXECUTE\s+IMMEDIATE\b/gi, kind: "flag", note: "BigQuery scripting (EXECUTE IMMEDIATE) — rewrite as a PL/pgSQL DO block or operations",
+        id: "scripting", },
+    { pattern: /\bGENERATE_UUID\s*\(\s*\)/g, kind: "flag", note: "GENERATE_UUID() → gen_random_uuid()",
+        id: "generate-uuid", },
     {
         pattern: /`[A-Za-z0-9_-]+\.[A-Za-z0-9_$]+\.[A-Za-z0-9_$]+`/g,
         kind: "flag",
@@ -54706,10 +55323,394 @@ ${description}    columnTypes: {
         ],
     };
 }
+function maskSql(text, keepStrings = false) {
+    let out = text.replace(/--[^\n]*/g, m => " ".repeat(m.length));
+    out = out.replace(/\/\*[\s\S]*?\*\//g, m => " ".repeat(m.length));
+    if (!keepStrings) {
+        out = out.replace(/'(?:[^']|'')*'/g, m => `'${" ".repeat(Math.max(0, m.length - 2))}'`);
+    }
+    return out;
+}
+function matchParen(text, open) {
+    let depth = 0;
+    for (let i = open; i < text.length; i++) {
+        if (text[i] === "(")
+            depth++;
+        else if (text[i] === ")" && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+function splitArgs(src, mask, from, to) {
+    const parts = [];
+    let depth = 0;
+    let start = from;
+    for (let i = from; i < to; i++) {
+        const ch = mask[i];
+        if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        else if (ch === "," && depth === 0) {
+            parts.push(src.slice(start, i).trim());
+            start = i + 1;
+        }
+    }
+    parts.push(src.slice(start, to).trim());
+    return parts;
+}
+const INTERVAL_ARG = /^interval\s+(\d+)\s+([a-z]+)$/i;
+const TYPE_NAMES = {
+    string: "text",
+    int64: "bigint",
+    float64: "double precision",
+    numeric: "numeric",
+    bignumeric: "numeric",
+    bool: "boolean",
+    bytes: "bytea",
+    datetime: "timestamp",
+    timestamp: "timestamptz",
+};
+function pgType(bqType) {
+    var _a;
+    const t = bqType.trim().toLowerCase();
+    return (_a = TYPE_NAMES[t]) !== null && _a !== void 0 ? _a : t;
+}
+const CALL_RULES = [
+    {
+        name: "cast",
+        note: "CAST(x AS <BigQuery type>) → the PostgreSQL type name",
+        rewrite(args) {
+            if (args.length !== 1)
+                return null;
+            const m = /^([\s\S]*?)\s+as\s+([A-Za-z][\w ]*)$/i.exec(args[0]);
+            if (!m)
+                return null;
+            const t = pgType(m[2]);
+            return t === m[2].trim().toLowerCase() ? null : `cast(${m[1]} as ${t})`;
+        },
+    },
+    {
+        name: "safe_cast",
+        note: "SAFE_CAST → guarded cast via pg_input_is_valid (NULL on bad input, as in BigQuery)",
+        rewrite(args) {
+            if (args.length !== 1)
+                return null;
+            const m = /^([\s\S]*?)\s+as\s+([A-Za-z][\w ]*)$/i.exec(args[0]);
+            if (!m)
+                return null;
+            const [, expr, type] = m;
+            const t = pgType(type);
+            if (t === "text")
+                return `(${expr})::text`;
+            return `(case when pg_input_is_valid((${expr})::text, '${t}') then (${expr})::${t} end)`;
+        },
+    },
+    {
+        name: "safe_divide",
+        note: "SAFE_DIVIDE(a, b) → a / nullif(b, 0)",
+        rewrite: args => (args.length === 2 ? `(${args[0]} / nullif(${args[1]}, 0))` : null),
+    },
+    {
+        name: "collate",
+        note: "COLLATE(x, '') → x (collation stripping is a no-op in PostgreSQL)",
+        rewrite: args => args.length === 2 && (args[1] === "''" || args[1] === '""') ? args[0] : null,
+    },
+    {
+        name: "regexp_extract",
+        note: "REGEXP_EXTRACT(x, pattern) → substring(x from pattern)",
+        rewrite: args => (args.length === 2 ? `substring(${args[0]} from ${args[1]})` : null),
+    },
+    {
+        name: "split",
+        note: "SPLIT(x, d) → string_to_array(x, d); an empty delimiter becomes NULL (per character)",
+        rewrite(args) {
+            if (args.length !== 2)
+                return null;
+            const d = args[1] === "''" || args[1] === '""' ? "NULL" : args[1];
+            return `string_to_array(${args[0]}, ${d})`;
+        },
+    },
+    {
+        name: "date_sub",
+        note: "DATE_SUB(d, INTERVAL n unit) → (d - interval 'n unit')",
+        rewrite(args) {
+            if (args.length !== 2)
+                return null;
+            const m = INTERVAL_ARG.exec(args[1]);
+            return m ? `(${args[0]} - interval '${m[1]} ${m[2].toLowerCase()}')` : null;
+        },
+    },
+    {
+        name: "date_add",
+        note: "DATE_ADD(d, INTERVAL n unit) → (d + interval 'n unit')",
+        rewrite(args) {
+            if (args.length !== 2)
+                return null;
+            const m = INTERVAL_ARG.exec(args[1]);
+            return m ? `(${args[0]} + interval '${m[1]} ${m[2].toLowerCase()}')` : null;
+        },
+    },
+    {
+        name: "date_diff",
+        note: "DATE_DIFF(a, b, DAY|HOUR) → PostgreSQL date/epoch arithmetic",
+        rewrite(args) {
+            if (args.length !== 3)
+                return null;
+            const unit = args[2].trim().toLowerCase();
+            if (unit === "day")
+                return `(${args[0]}::date - ${args[1]}::date)`;
+            if (unit === "hour") {
+                return (`(extract(epoch from date_trunc('hour', ${args[0]})` +
+                    ` - date_trunc('hour', ${args[1]})) / 3600)::bigint`);
+            }
+            return null;
+        },
+    },
+    {
+        name: "unix_seconds",
+        note: "UNIX_SECONDS(ts) → extract(epoch from ts)::bigint",
+        rewrite: args => (args.length === 1 ? `extract(epoch from ${args[0]})::bigint` : null),
+    },
+];
+function applyCallRules(text, isRewritableOffset) {
+    const applied = [];
+    let result = text;
+    for (let pass = 0; pass < 10; pass++) {
+        const mask = maskSql(result);
+        const sites = [];
+        for (const rule of CALL_RULES) {
+            const finder = new RegExp(`\\b${rule.name}\\s*\\(`, "gi");
+            let m;
+            while ((m = finder.exec(mask)) !== null) {
+                const open = m.index + m[0].length - 1;
+                const close = matchParen(mask, open);
+                if (close < 0 || !isRewritableOffset(m.index))
+                    continue;
+                const out = rule.rewrite(splitArgs(result, mask, open + 1, close));
+                if (out === null)
+                    continue;
+                sites.push({ start: m.index, end: close + 1, out, note: rule.note });
+            }
+        }
+        if (!sites.length)
+            break;
+        sites.sort((a, b) => b.start - a.start);
+        const seen = [];
+        for (const s of sites) {
+            if (seen.some(p => s.start < p.end && p.start < s.end))
+                continue;
+            seen.push(s);
+            applied.push({ line: result.slice(0, s.start).split("\n").length, note: s.note });
+            result = result.slice(0, s.start) + s.out + result.slice(s.end);
+        }
+    }
+    const before = result;
+    result = result.replace(/\[\s*(?:SAFE_)?OFFSET\s*\(\s*([^()]*?)\s*\)\s*\]/gi, (_all, idx) => (/^\d+$/.test(idx) ? `[${Number(idx) + 1}]` : `[(${idx}) + 1]`));
+    if (result !== before) {
+        applied.push({ line: 1, note: "array[OFFSET(n)] → array[n + 1] (PostgreSQL is 1-based)" });
+    }
+    result = parenthesiseSubscriptedCalls(result);
+    return { text: result, applied };
+}
+function jsBlockSpans(source) {
+    const spans = [];
+    const re = /(^|\n)\s*js\s*\{/g;
+    let m;
+    while ((m = re.exec(source))) {
+        const open = source.indexOf("{", m.index + m[0].length - 1);
+        const close = matchParenLike(source, open, "{", "}");
+        spans.push({ start: m.index, end: close < 0 ? source.length : close + 1 });
+    }
+    return spans;
+}
+function matchParenLike(text, open, o, c) {
+    let depth = 0;
+    for (let i = open; i < text.length; i++) {
+        if (text[i] === o)
+            depth++;
+        else if (text[i] === c && --depth === 0)
+            return i;
+    }
+    return -1;
+}
+function applyTextRules(text, isSqlOffset, applied) {
+    const note = (offset, n) => applied.push({ line: text.slice(0, offset).split("\n").length, note: n });
+    const rewrite = (src, mask, pattern, replace, ruleNote) => {
+        const edits = [];
+        let m;
+        pattern.lastIndex = 0;
+        while ((m = pattern.exec(mask)) !== null) {
+            if (!isSqlOffset(m.index))
+                continue;
+            const sub = replace(m);
+            if (sub !== null)
+                edits.push({ start: m.index, end: m.index + m[0].length, out: sub });
+        }
+        let out = src;
+        for (const e of edits.reverse()) {
+            note(e.start, ruleNote);
+            out = out.slice(0, e.start) + e.out + out.slice(e.end);
+        }
+        return out;
+    };
+    let result = text;
+    result = rewrite(result, maskSql(result, true), /(?<![\w"'])#[^\n]*/g, m => `--${m[0].slice(1)}`, "# line comment → -- (PostgreSQL has no # comment)");
+    result = rewrite(result, maskSql(result, true), /(?<![A-Za-z0-9_])[rR](?=['"])/g, () => "", "r'…' raw string → '…' (no raw-string prefix in PostgreSQL)");
+    result = rewrite(result, maskSql(result, true), /(\bas\s+)?"([^"\n]*)"/gi, m => {
+        if (m[1])
+            return null;
+        return m[2].includes("${") || m[2].includes("'") ? null : `'${m[2]}'`;
+    }, 'BigQuery "string" → \'string\' (double quotes are identifiers in PostgreSQL)');
+    result = rewrite(result, maskSql(result), /`([^`\n]+)`/g, m => (m[1].includes(".") || m[1].includes("${") ? null : `"${m[1]}"`), "`identifier` → \"identifier\"");
+    result = rewrite(result, maskSql(result, true), /\s+collate\s+(''|"")/gi, () => "", "x COLLATE '' → x (collation stripping is a no-op in PostgreSQL)");
+    for (;;) {
+        const mask = maskSql(result);
+        const m = /\bextract\s*\(\s*dayofweek\s+from\s+/i.exec(mask);
+        if (!m || !isSqlOffset(m.index))
+            break;
+        const close = matchParen(mask, mask.indexOf("(", m.index));
+        if (close < 0)
+            break;
+        const inner = result.slice(m.index + m[0].length, close).trim();
+        note(m.index, "EXTRACT(DAYOFWEEK FROM x) → extract(dow from x) + 1 (BigQuery is 1-based)");
+        result =
+            result.slice(0, m.index) + `(extract(dow from ${inner}) + 1)` + result.slice(close + 1);
+    }
+    return rewriteUnenforcedConstraints(result, isSqlOffset, applied);
+}
+const UNENFORCED_HEADER = [
+    "BigQuery declared the constraint below NOT ENFORCED — advisory metadata for BI tools,",
+    "never checked by the warehouse. PostgreSQL has no unenforced constraint, so the real",
+    "equivalent is written out here and left commented: uncommenting enforces it, and it will",
+    "fail if the data violates it. A foreign key also needs the referenced table's own key to",
+    "exist, so enable those upstream first.",
+];
+function rewriteUnenforcedConstraints(text, isSqlOffset, applied) {
+    const mask = maskSql(text);
+    const sites = [];
+    const finder = /\bALTER\s+TABLE\b/gi;
+    let m;
+    while ((m = finder.exec(mask)) !== null) {
+        let depth = 0;
+        let end = mask.length;
+        for (let i = m.index; i < mask.length; i++) {
+            if (mask[i] === "(")
+                depth++;
+            else if (mask[i] === ")")
+                depth--;
+            else if (mask[i] === ";" && depth === 0) {
+                end = i + 1;
+                break;
+            }
+        }
+        finder.lastIndex = end;
+        const stmt = text.slice(m.index, end);
+        if (!/NOT\s+ENFORCED/i.test(stmt) || !isSqlOffset(m.index))
+            continue;
+        const body = stmt.replace(/;\s*$/, "").replace(/^ALTER\s+TABLE\s*/i, "");
+        const firstAction = /\b(ADD|DROP|ALTER)\b/i.exec(body);
+        if (!firstAction)
+            continue;
+        const target = body.slice(0, firstAction.index).trim();
+        const actions = splitTopLevel(body.slice(firstAction.index))
+            .map(a => a.trim())
+            .filter(a => /^ADD\b/i.test(a))
+            .map(a => a.replace(/\s*\bNOT\s+ENFORCED\b/gi, "").trim());
+        if (!actions.length)
+            continue;
+        const lineStart = text.lastIndexOf("\n", m.index) + 1;
+        const indent = /^[ \t]*/.exec(text.slice(lineStart))[0];
+        const commented = [
+            ...UNENFORCED_HEADER.map(l => `-- ${l}`),
+            ...(actions.length === 1
+                ? [`-- ALTER TABLE ${target} ${actions[0]};`]
+                : [
+                    `-- ALTER TABLE ${target}`,
+                    ...actions.map((a, i) => `--   ${a}${i === actions.length - 1 ? ";" : ","}`),
+                ]),
+        ].join(`\n${indent}`);
+        sites.push({ start: m.index, end, out: commented });
+    }
+    let result = text;
+    for (const s of sites.reverse()) {
+        applied.push({
+            line: text.slice(0, s.start).split("\n").length,
+            note: "NOT ENFORCED constraint → PostgreSQL equivalent, commented out " +
+                "(enforcing it may fail on data that has never been checked)",
+        });
+        result = result.slice(0, s.start) + s.out + result.slice(s.end);
+    }
+    return result;
+}
+function splitTopLevel(s) {
+    const parts = [];
+    let depth = 0;
+    let cur = "";
+    for (const ch of s) {
+        if (ch === "(")
+            depth++;
+        else if (ch === ")")
+            depth--;
+        if (ch === "," && depth === 0) {
+            parts.push(cur);
+            cur = "";
+        }
+        else
+            cur += ch;
+    }
+    parts.push(cur);
+    return parts;
+}
+function parenthesiseSubscriptedCalls(text) {
+    const finder = /\b[A-Za-z_]\w*\s*\(/g;
+    const spans = [];
+    let m;
+    while ((m = finder.exec(text)) !== null) {
+        const close = matchParen(text, m.index + m[0].length - 1);
+        if (close < 0)
+            continue;
+        if (/^\s*\[/.test(text.slice(close + 1)))
+            spans.push({ start: m.index, end: close + 1 });
+    }
+    let out = text;
+    for (const s of spans.reverse()) {
+        out = `${out.slice(0, s.start)}(${out.slice(s.start, s.end)})${out.slice(s.end)}`;
+    }
+    return out;
+}
 function convertTarget(source, jsMode, dialect = "postgres") {
+    var _a;
     const dialectPass = dialect === "postgres";
-    const span = jsMode ? null : findConfigBlock(source);
+    let span = jsMode ? null : findConfigBlock(source);
     const findings = [];
+    if (dialectPass) {
+        const outsideConfig = (off) => {
+            const s = jsMode ? null : findConfigBlock(source);
+            return !s || off < s.start || off >= s.end;
+        };
+        const called = applyCallRules(source, outsideConfig);
+        if (called.text !== source)
+            source = called.text;
+        for (const a of called.applied) {
+            findings.push({ line: a.line, kind: "rewrite", note: a.note, class: classIdFor(a.note) });
+        }
+        const textApplied = [];
+        const jsSpans = jsMode ? [{ start: 0, end: source.length }] : jsBlockSpans(source);
+        const templates = tokenize(source).filter(t => t.kind === "template");
+        source = applyTextRules(source, off => outsideConfig(off) &&
+            !jsSpans.some(s => off >= s.start && off < s.end) &&
+            !templates.some(t => off >= t.start && off < t.end), textApplied);
+        for (const a of textApplied) {
+            findings.push({
+                line: a.line,
+                kind: "rewrite",
+                note: a.note,
+                class: a.note.startsWith("NOT ENFORCED") ? "not-enforced" : classIdFor(a.note),
+            });
+        }
+        span = jsMode ? null : findConfigBlock(source);
+    }
     const lines = source.split("\n");
     const jsLines = jsMode ? new Set() : jsBlockLines(source);
     let configStartLine = -1;
@@ -54774,15 +55775,16 @@ function convertTarget(source, jsMode, dialect = "postgres") {
                 rule.pattern.lastIndex = 0;
                 if (!rule.pattern.test(line))
                     continue;
+                const cls = (_a = rule.id) !== null && _a !== void 0 ? _a : classIdFor(rule.note);
                 if (rule.replacement !== undefined) {
                     rule.pattern.lastIndex = 0;
                     line = line.replace(rule.pattern, rule.replacement);
-                    findings.push({ line: lineNo, kind: "rewrite", note: rule.note });
+                    findings.push({ line: lineNo, kind: "rewrite", note: rule.note, class: cls });
                     if (markersSafe)
                         notesForLine.push(rule.note);
                 }
                 else {
-                    findings.push({ line: lineNo, kind: "flag", note: rule.note });
+                    findings.push({ line: lineNo, kind: "flag", note: rule.note, class: cls });
                     if (markersSafe)
                         notesForLine.push(rule.note);
                 }
@@ -54858,6 +55860,8 @@ async function migrateDataform(opts) {
         files: [],
         skippedForSafety: [],
         warnings: [],
+        todo: [],
+        applied: [],
     };
     const sqlxFiles = [];
     for (const rel of files) {
@@ -55089,6 +56093,8 @@ async function migrateDataform(opts) {
     if (skippedForSafety.size > 0) {
         report.warnings.push(`Skipped ${skippedForSafety.size} file(s)/dir(s) for safety (credentials, build artifacts, VCS) — see skippedForSafety`);
     }
+    buildTriage(report);
+    analyseStructArrays(report, outDir);
     writer.write("migration-report.json", JSON.stringify(report, null, 2));
     writer.write("migration-report.md", renderReportMd(report));
     return report;
@@ -55150,6 +56156,71 @@ function renderReportMd(r) {
                 `of BigQuery connections.`);
         }
     }
+    if (r.todo.length) {
+        const needing = r.todo.filter(t => t.owner === "needs-decision");
+        const mechanical = r.todo.filter(t => t.owner === "mechanical");
+        lines.push("");
+        lines.push(`## What is left to do`);
+        lines.push("");
+        lines.push(`${r.todo.reduce((n, t) => n + t.count, 0)} site(s) across ${r.todo.length} construct(s). ` +
+            `Work them largest-first within each section — the ordering below already does that.`);
+        lines.push("");
+        lines.push(`**${mechanical.reduce((n, t) => n + t.count, 0)} site(s) are mechanical** — one correct ` +
+            `answer, no judgement needed. **${needing.reduce((n, t) => n + t.count, 0)} site(s) need a ` +
+            `decision** that cannot be read off the SQL: whether a feature is still wanted, what a ` +
+            `structure should become, whether a behaviour was deliberate.`);
+        const severityLabel = {
+            "changes-meaning": "⚠ runs, but may return DIFFERENT RESULTS",
+            "fails-at-run": "fails when the action runs",
+            "blocks-compile": "fails to compile",
+        };
+        const section = (title, items, preamble) => {
+            var _a;
+            if (!items.length)
+                return;
+            lines.push("");
+            lines.push(`### ${title}`);
+            lines.push("");
+            lines.push(preamble);
+            for (const t of items) {
+                lines.push("");
+                lines.push(`- [ ] **${t.title}** — ${t.count} site(s) · ${severityLabel[t.severity]}`);
+                if (t.postgres)
+                    lines.push(`      - PostgreSQL: ${t.postgres}`);
+                if (t.why)
+                    lines.push(`      - ${t.why}`);
+                const shown = t.locations.slice(0, 8);
+                for (const l of shown) {
+                    lines.push(`      - \`${l.file}\` L${l.lines.slice(0, 6).join(", L")}`);
+                }
+                if (t.locations.length > shown.length) {
+                    lines.push(`      - …and ${t.locations.length - shown.length} more file(s)`);
+                }
+                for (const s of (_a = t.sql) !== null && _a !== void 0 ? _a : []) {
+                    lines.push("");
+                    lines.push(`      \`${s.file}\` L${s.line} — ${s.note}`);
+                    lines.push("");
+                    lines.push("      ```sql");
+                    for (const l of s.sql.split("\n"))
+                        lines.push(`      ${l}`);
+                    lines.push("      ```");
+                }
+            }
+        };
+        section("Needs a decision", needing, "Start here — these gate the rest, and each is a question for whoever owns the data, not " +
+            "something to work out from the code.");
+        section("Mechanical", mechanical, "These have one correct answer and can be worked through without further input.");
+    }
+    if (r.applied.length) {
+        lines.push("");
+        lines.push(`## Rewrites applied automatically`);
+        lines.push("");
+        lines.push(`Listed so they can be reviewed rather than trusted — a converted project is worth reading ` +
+            `before it is run.`);
+        lines.push("");
+        for (const a of r.applied)
+            lines.push(`- ${a.title} — ${a.count}`);
+    }
     lines.push("");
     lines.push(`## Target files (${targets.length})`);
     lines.push("");
@@ -55211,6 +56282,454 @@ function renderReportMd(r) {
     return lines.join("\n");
 }
 
+function parseColumnTypes(config) {
+    const m = /\bcolumnTypes\s*:\s*\{/.exec(config);
+    if (!m)
+        return [];
+    let depth = 0;
+    let end = config.length;
+    for (let i = m.index + m[0].length - 1; i < config.length; i++) {
+        if (config[i] === "{")
+            depth++;
+        else if (config[i] === "}" && --depth === 0) {
+            end = i;
+            break;
+        }
+    }
+    const body = config.slice(m.index + m[0].length, end);
+    const withoutComments = body.replace(/\/\/[^\n]*/g, "");
+    return [...withoutComments.matchAll(/(^|,)\s*([A-Za-z_]\w*)\s*:/g)].map(x => x[2]);
+}
+function loadActions(projectDir) {
+    const actions = [];
+    const walk = (dir) => {
+        var _a;
+        if (!fs__namespace.existsSync(dir))
+            return;
+        for (const entry of fs__namespace.readdirSync(dir, { withFileTypes: true })) {
+            const full = path__namespace.join(dir, entry.name);
+            if (entry.isDirectory())
+                walk(full);
+            else if (entry.name.endsWith(".sqlx")) {
+                const source = fs__namespace.readFileSync(full, "utf8");
+                const span = findConfigBlock(source);
+                const config = span ? source.slice(span.start, span.end) : "";
+                const parsed = parseSqlxConfig(config);
+                actions.push({
+                    file: path__namespace.relative(projectDir, full),
+                    type: parsed.type,
+                    name: (_a = parsed.name) !== null && _a !== void 0 ? _a : path__namespace.basename(entry.name, ".sqlx"),
+                    schema: parsed.schema,
+                    columns: parseColumnTypes(config),
+                    body: span ? source.slice(span.end) : source,
+                    bodyOffset: span ? span.end : 0,
+                    source,
+                });
+            }
+        }
+    };
+    walk(path__namespace.join(projectDir, "definitions"));
+    return actions;
+}
+function outputName(toks, start, end) {
+    var _a, _b;
+    const items = toks.slice(start, end);
+    if (!items.length)
+        return null;
+    if (items.some(t => t.text === "*"))
+        return null;
+    const last = items[items.length - 1];
+    if (isWord(items[items.length - 2], "as")) {
+        return ((_a = last.value) !== null && _a !== void 0 ? _a : last.text).replace(/^"|"$/g, "");
+    }
+    const bare = items.filter(t => t.text !== ".");
+    if (bare.every(t => t.kind === "word" || t.kind === "quoted-ident")) {
+        return ((_b = last.value) !== null && _b !== void 0 ? _b : last.text).replace(/^"|"$/g, "");
+    }
+    return null;
+}
+class Resolver {
+    constructor(actions) {
+        var _a;
+        this.actions = actions;
+        this.byName = new Map();
+        this.byPair = new Map();
+        this.memo = new Map();
+        for (const a of actions) {
+            this.byName.set(a.name, [...((_a = this.byName.get(a.name)) !== null && _a !== void 0 ? _a : []), a]);
+            if (a.schema)
+                this.byPair.set(`${a.schema}.${a.name}`, a);
+        }
+    }
+    resolveRef(tok) {
+        var _a;
+        const args = [...tok.text.matchAll(/["']([^"']+)["']/g)].map(m => m[1]);
+        if (!args.length)
+            return { reason: "ref with no literal arguments" };
+        const name = args[args.length - 1];
+        if (args.length >= 2) {
+            const hit = this.byPair.get(`${args[args.length - 2]}.${name}`);
+            return hit ? { action: hit } : { reason: `no action ${args[args.length - 2]}.${name}` };
+        }
+        const candidates = (_a = this.byName.get(name)) !== null && _a !== void 0 ? _a : [];
+        if (!candidates.length)
+            return { reason: `unknown action ${name}` };
+        if (candidates.length > 1)
+            return { reason: `ambiguous action ${name}` };
+        return { action: candidates[0] };
+    }
+    columnsOf(action, seen = new Set()) {
+        if (action.columns.length)
+            return action.columns;
+        if (action.type === "declaration")
+            return null;
+        if (seen.has(action.file))
+            return null;
+        const memo = this.memo.get(action.file);
+        if (memo !== undefined && !seen.size)
+            return memo;
+        seen.add(action.file);
+        const result = this.selectColumns(action.body, new Set(seen));
+        if (!seen.size)
+            this.memo.set(action.file, result);
+        return result;
+    }
+    selectColumns(sql, seen) {
+        var _a;
+        const toks = significant(tokenize(sql));
+        const scopes = selectScopes(toks);
+        if (!scopes.length)
+            return null;
+        const scope = scopes.reduce((best, s) => (s.select > best.select ? s : best), scopes[0]);
+        const rels = scope.from === -1 ? [] : relationsIn(toks, scope.fromStart, scope.fromEnd);
+        const names = [];
+        for (const [s, e] of splitOnCommas(toks, scope.listStart, scope.listEnd)) {
+            const item = toks.slice(s, e);
+            const star = item.findIndex(t => t.text === "*");
+            if (star === -1) {
+                const n = outputName(toks, s, e);
+                if (n === null)
+                    return null;
+                names.push(n);
+                continue;
+            }
+            const qualifier = star >= 2 && ((_a = item[star - 1]) === null || _a === void 0 ? void 0 : _a.text) === "." ? item[star - 2].text.toLowerCase() : null;
+            const rel = qualifier ? rels.find(r => r.alias === qualifier) : rels[0];
+            if (!rel)
+                return null;
+            const cols = this.relationColumns(rel.tokens, rel.subquery, seen);
+            if (!cols)
+                return null;
+            const excluded = starExclusions(item, star);
+            names.push(...cols.filter(c => !excluded.has(c.toLowerCase())));
+        }
+        return names.length ? names : null;
+    }
+    relationColumns(tokens, subquery, seen) {
+        if (subquery) {
+            const inner = tokens
+                .slice(1, -1)
+                .map(t => t.text)
+                .join(" ");
+            return this.selectColumns(inner, seen);
+        }
+        const tmpl = tokens.find(t => t.kind === "template");
+        if (tmpl) {
+            const { action } = this.resolveRef(tmpl);
+            return action ? this.columnsOf(action, seen) : null;
+        }
+        return null;
+    }
+}
+function starExclusions(item, star) {
+    var _a, _b;
+    const out = new Set();
+    if (!isWord(item[star + 1], "except"))
+        return out;
+    const open = star + 2;
+    if (((_a = item[open]) === null || _a === void 0 ? void 0 : _a.text) !== "(")
+        return out;
+    const close = matchBracket(item, open);
+    if (close < 0)
+        return out;
+    for (const [s, e] of splitOnCommas(item, open + 1, close)) {
+        const t = item[s];
+        if (t)
+            out.add(((_b = t.value) !== null && _b !== void 0 ? _b : t.text).replace(/^"|"$/g, "").toLowerCase());
+    }
+    return out;
+}
+function quoteIfNeeded(col) {
+    return /^[a-z_][a-z0-9_]*$/.test(col) ? col : `"${col}"`;
+}
+const MARKER = "-- sqlanvil:star-except";
+async function migrateFix(opts) {
+    var _a;
+    const result = { expanded: 0, groupByAll: 0, files: [], unresolved: [] };
+    const touched = new Set();
+    for (let pass = 0; pass < 12; pass++) {
+        const actions = loadActions(opts.projectDir);
+        const resolver = new Resolver(actions);
+        let changedThisPass = false;
+        result.unresolved = [];
+        for (const action of actions) {
+            const source = action.source;
+            const toks = significant(tokenize(source));
+            const scopes = selectScopes(toks);
+            const edits = [];
+            for (const scope of scopes) {
+                const rels = scope.from === -1 ? [] : relationsIn(toks, scope.fromStart, scope.fromEnd);
+                for (const [s, e] of splitOnCommas(toks, scope.listStart, scope.listEnd)) {
+                    const item = toks.slice(s, e);
+                    const star = item.findIndex(t => t.text === "*");
+                    if (star === -1 || !isWord(item[star + 1], "except"))
+                        continue;
+                    const line = source.slice(0, item[star].start).split("\n").length;
+                    const qualifier = star >= 2 && ((_a = item[star - 1]) === null || _a === void 0 ? void 0 : _a.text) === "." ? item[star - 2].text.toLowerCase() : null;
+                    const rel = qualifier ? rels.find(r => r.alias === qualifier) : rels[0];
+                    if (!rel) {
+                        result.unresolved.push({
+                            file: action.file,
+                            line,
+                            reason: qualifier
+                                ? `no relation aliased "${qualifier}" in the FROM/JOIN chain`
+                                : "star has no FROM relation",
+                        });
+                        continue;
+                    }
+                    let cols = resolver.relationColumns(rel.tokens, rel.subquery, new Set());
+                    if (!cols) {
+                        const bare = rel.tokens.map(t => t.text).join("");
+                        const cte = cteColumns(source, bare, resolver);
+                        cols = cte;
+                    }
+                    if (!cols) {
+                        const shown = rel.tokens.map(t => t.text).join("");
+                        result.unresolved.push({
+                            file: action.file,
+                            line,
+                            reason: rel.tokens.some(t => t.kind === "template")
+                                ? `columns of ${shown} are unknown — has introspect run for it?`
+                                : `cannot determine the columns of ${shown}`,
+                        });
+                        continue;
+                    }
+                    const excluded = starExclusions(item, star);
+                    const missing = [...excluded].filter(x => !cols.some(c => c.toLowerCase() === x));
+                    if (missing.length) {
+                        result.unresolved.push({
+                            file: action.file,
+                            line,
+                            reason: `EXCEPT names ${missing.join(", ")}, which the source does not have`,
+                        });
+                        continue;
+                    }
+                    const keep = cols.filter(c => !excluded.has(c.toLowerCase()));
+                    if (!keep.length) {
+                        result.unresolved.push({
+                            file: action.file,
+                            line,
+                            reason: "the EXCEPT list removes every column",
+                        });
+                        continue;
+                    }
+                    const close = matchBracket(item, star + 2);
+                    const lineStart = source.lastIndexOf("\n", item[star].start) + 1;
+                    const indent = /^[ \t]*/.exec(source.slice(lineStart))[0] + "  ";
+                    const prefix = qualifier ? `${qualifier}.` : "";
+                    const body = keep.map(c => `${indent}${prefix}${quoteIfNeeded(c)}`).join(",\n");
+                    const marker = `${indent}${MARKER} ${prefix}* from ` +
+                        `${rel.tokens.map(t => t.text).join("")} minus (${[...excluded].join(", ")})`;
+                    edits.push({
+                        start: qualifier ? item[star - 2].start : item[star].start,
+                        end: item[close].end,
+                        out: `\n${marker}\n${body}`,
+                    });
+                }
+            }
+            if (!edits.length)
+                continue;
+            let out = source;
+            for (const edit of edits.sort((a, b) => b.start - a.start)) {
+                const head = out.slice(0, edit.start).replace(/[ \t]+$/, "");
+                out = head + edit.out + out.slice(edit.end);
+                result.expanded++;
+            }
+            changedThisPass = true;
+            touched.add(action.file);
+            if (opts.write) {
+                fs__namespace.writeFileSync(path__namespace.join(opts.projectDir, action.file), out);
+            }
+            else {
+                action.source = out;
+            }
+        }
+        if (!changedThisPass || !opts.write)
+            break;
+    }
+    for (const action of loadActions(opts.projectDir)) {
+        const { text, expanded, unresolved } = expandGroupByAll(action.source);
+        for (const u of unresolved) {
+            result.unresolved.push({ file: action.file, line: u.line, reason: u.reason });
+        }
+        if (!expanded)
+            continue;
+        result.groupByAll += expanded;
+        touched.add(action.file);
+        if (opts.write)
+            fs__namespace.writeFileSync(path__namespace.join(opts.projectDir, action.file), text);
+    }
+    result.files = [...touched].sort();
+    if (opts.write)
+        updateMigrationReport(opts.projectDir, result);
+    return result;
+}
+function updateMigrationReport(projectDir, result) {
+    var _a, _b, _c;
+    const jsonPath = path__namespace.join(projectDir, "migration-report.json");
+    if (!fs__namespace.existsSync(jsonPath))
+        return;
+    let report;
+    try {
+        report = JSON.parse(fs__namespace.readFileSync(jsonPath, "utf8"));
+    }
+    catch (_d) {
+        return;
+    }
+    if (!Array.isArray(report.todo))
+        return;
+    const OWNED = new Set(["star-except", "group-by-all"]);
+    const remaining = new Map();
+    for (const site of result.unresolved) {
+        const id = /GROUP BY ALL/i.test(site.reason) || /star expands/i.test(site.reason)
+            ? "group-by-all"
+            : "star-except";
+        const prior = report.todo.find(t => t.id === id);
+        const entry = (_a = remaining.get(id)) !== null && _a !== void 0 ? _a : {
+            id,
+            title: (_b = prior === null || prior === void 0 ? void 0 : prior.title) !== null && _b !== void 0 ? _b : id,
+            count: 0,
+            severity: (_c = prior === null || prior === void 0 ? void 0 : prior.severity) !== null && _c !== void 0 ? _c : "blocks-compile",
+            owner: "needs-decision",
+            postgres: prior === null || prior === void 0 ? void 0 : prior.postgres,
+            why: site.reason,
+            locations: [],
+        };
+        entry.count++;
+        const loc = entry.locations.find(l => l.file === site.file);
+        if (loc)
+            loc.lines.push(site.line);
+        else
+            entry.locations.push({ file: site.file, lines: [site.line] });
+        remaining.set(id, entry);
+    }
+    report.todo = [...report.todo.filter(t => !OWNED.has(t.id)), ...remaining.values()];
+    const applied = (n, id, title) => {
+        if (!n)
+            return;
+        const seen = report.applied.find(a => a.id === id);
+        if (seen)
+            seen.count = n;
+        else
+            report.applied.push({ id, title, count: n });
+    };
+    applied(result.expanded, "star-except", "SELECT * EXCEPT expanded (migrate-fix)");
+    applied(result.groupByAll, "group-by-all", "GROUP BY ALL rewritten as ordinals (migrate-fix)");
+    fs__namespace.writeFileSync(jsonPath, JSON.stringify(report, null, 2));
+    fs__namespace.writeFileSync(path__namespace.join(projectDir, "migration-report.md"), renderReportMd(report));
+}
+const AGGREGATES = new Set([
+    "count", "sum", "avg", "min", "max", "array_agg", "string_agg", "bool_and", "bool_or", "every",
+    "stddev", "stddev_pop", "stddev_samp", "variance", "var_pop", "var_samp", "jsonb_agg",
+    "json_agg", "jsonb_object_agg", "json_object_agg", "corr", "covar_pop", "covar_samp",
+    "percentile_cont", "percentile_disc", "bit_and", "bit_or", "logical_and", "logical_or",
+    "any_value", "countif",
+]);
+function isGroupable(item) {
+    var _a, _b;
+    for (let i = 0; i < item.length; i++) {
+        if (item[i].kind !== "word" || !AGGREGATES.has(item[i].text.toLowerCase()))
+            continue;
+        if (((_a = item[i + 1]) === null || _a === void 0 ? void 0 : _a.text) !== "(")
+            continue;
+        const close = matchBracket(item, i + 1);
+        if (close < 0)
+            return false;
+        let after = close + 1;
+        if (isWord(item[after], "filter") && ((_b = item[after + 1]) === null || _b === void 0 ? void 0 : _b.text) === "(") {
+            const filterClose = matchBracket(item, after + 1);
+            if (filterClose > 0)
+                after = filterClose + 1;
+        }
+        if (!isWord(item[after], "over"))
+            return false;
+    }
+    return !item.some((t, i) => isWord(t, "over") && i > 0);
+}
+function isStarItem(item) {
+    if (!item.length)
+        return false;
+    if (item[0].text === "*")
+        return true;
+    return item.length >= 3 && item[1].text === "." && item[2].text === "*";
+}
+function expandGroupByAll(source) {
+    const toks = significant(tokenize(source));
+    const scopes = selectScopes(toks);
+    const edits = [];
+    const unresolved = [];
+    for (let i = 0; i + 2 < toks.length; i++) {
+        if (!isWord(toks[i], "group") || !isWord(toks[i + 1], "by") || !isWord(toks[i + 2], "all")) {
+            continue;
+        }
+        const line = source.slice(0, toks[i].start).split("\n").length;
+        const scope = scopes.filter(s => s.select < i).pop();
+        if (!scope)
+            continue;
+        const items = splitOnCommas(toks, scope.listStart, scope.listEnd);
+        if (items.some(([s, e]) => isStarItem(toks.slice(s, e)))) {
+            unresolved.push({
+                line,
+                reason: "GROUP BY ALL over a select list containing `*` — the ordinals depend on how many " +
+                    "columns the star expands to",
+            });
+            continue;
+        }
+        const ordinals = items
+            .map(([s, e], idx) => (isGroupable(toks.slice(s, e)) ? idx + 1 : null))
+            .filter((n) => n !== null);
+        if (!ordinals.length) {
+            unresolved.push({ line, reason: "every select-list item is an aggregate" });
+            continue;
+        }
+        edits.push({ start: toks[i + 2].start, end: toks[i + 2].end, out: ordinals.join(", ") });
+    }
+    let text = source;
+    for (const e of edits.reverse()) {
+        text = text.slice(0, e.start) + e.out + text.slice(e.end);
+    }
+    return { text, expanded: edits.length, unresolved };
+}
+function cteColumns(source, name, resolver) {
+    var _a;
+    const toks = significant(tokenize(source));
+    for (let i = 0; i < toks.length; i++) {
+        if (toks[i].kind !== "word" || toks[i].text.toLowerCase() !== name.toLowerCase())
+            continue;
+        if (!isWord(toks[i + 1], "as") || ((_a = toks[i + 2]) === null || _a === void 0 ? void 0 : _a.text) !== "(")
+            continue;
+        const close = matchBracket(toks, i + 2);
+        if (close < 0)
+            return null;
+        const inner = toks
+            .slice(i + 3, close)
+            .map(t => t.text)
+            .join(" ");
+        return resolver.selectColumns(inner, new Set());
+    }
+    return null;
+}
+
 function actuallyResolve(...filePaths) {
     return path__namespace.resolve(...filePaths.map(filePath => untildify__default["default"](filePath)));
 }
@@ -56606,6 +58125,8 @@ function createYargsCli(cli) {
     for (const command of cli.commands) {
         yargsChain = yargsChain.command(command.format, command.description, (yargsChainer) => createOptionsChain(yargsChainer, command), async (argv) => {
             const exitCode = await command.processFn(argv);
+            await new Promise(resolve => process.stdout.write("", () => resolve()));
+            await new Promise(resolve => process.stderr.write("", () => resolve()));
             process.exit(exitCode);
         });
     }
@@ -58346,6 +59867,39 @@ function runCli() {
                     print(`Next: sqlanvil compile ${argv["out-dir"]}`);
                     return 0;
                 }
+            },
+            {
+                format: "migrate-fix [project-dir]",
+                description: "Finish a converted project's dialect work, AFTER `scripts/introspect_all.sh` has run. " +
+                    "Expands `SELECT * EXCEPT (...)` into explicit column lists and rewrites `GROUP BY ALL` " +
+                    "as positional ordinals — both need the source columns that only exist once " +
+                    "declarations have been introspected, so this is the " +
+                    "third phase of a migration (convert, introspect, fix), not part of the conversion. " +
+                    "Re-runnable; reports anything it could not resolve instead of guessing.",
+                positionalOptions: [projectDirMustExistOption],
+                options: [
+                    option("dry-run", {
+                        describe: "Report what would change without writing.",
+                        type: "boolean",
+                        default: false
+                    })
+                ],
+                processFn: async (argv) => {
+                    const result = await migrateFix({
+                        projectDir: argv["project-dir"],
+                        write: !argv["dry-run"]
+                    });
+                    const verb = argv["dry-run"] ? "would rewrite" : "rewrote";
+                    print(`${verb} ${result.expanded} star-except site(s) and ${result.groupByAll} ` +
+                        `GROUP BY ALL clause(s) across ${result.files.length} file(s).`);
+                    if (result.unresolved.length) {
+                        printError(`${result.unresolved.length} site(s) need a look:`);
+                        for (const u of result.unresolved) {
+                            printError(`  ${u.file}:${u.line} — ${u.reason}`);
+                        }
+                    }
+                    return result.unresolved.length ? 1 : 0;
+                }
             }
         ]
     })