@sqlanvil/cli 1.27.2 → 1.29.0

package/bundle.js

@@ -151,6 +151,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {string|null} [warehouse] WorkflowSettings warehouse
          * @property {Object.<string,sqlanvil.IConnectionConfig>|null} [connections] WorkflowSettings connections
          * @property {Object.<string,sqlanvil.IEnvironment>|null} [environments] WorkflowSettings environments
+         * @property {boolean|null} [preserveGovernanceControls] WorkflowSettings preserveGovernanceControls
          */
 
         /**
@@ -323,6 +324,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         WorkflowSettings.prototype.environments = $util.emptyObject;
 
+        /**
+         * WorkflowSettings preserveGovernanceControls.
+         * @member {boolean} preserveGovernanceControls
+         * @memberof sqlanvil.WorkflowSettings
+         * @instance
+         */
+        WorkflowSettings.prototype.preserveGovernanceControls = false;
+
         /**
          * Creates a new WorkflowSettings instance using the specified properties.
          * @function create
@@ -396,6 +405,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                     writer.uint32(/* id 19, wireType 2 =*/154).fork().uint32(/* id 1, wireType 2 =*/10).string(keys[i]);
                     $root.sqlanvil.Environment.encode(message.environments[keys[i]], writer.uint32(/* id 2, wireType 2 =*/18).fork(), q + 1).ldelim().ldelim();
                 }
+            if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                writer.uint32(/* id 20, wireType 0 =*/160).bool(message.preserveGovernanceControls);
             return writer;
         };
 
@@ -575,6 +586,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.environments[key] = value;
                         break;
                     }
+                case 20: {
+                        message.preserveGovernanceControls = reader.bool();
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -696,6 +711,9 @@ const sqlanvil = $root.sqlanvil = (() => {
                         return "environments." + error;
                 }
             }
+            if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                if (typeof message.preserveGovernanceControls !== "boolean")
+                    return "preserveGovernanceControls: boolean expected";
             return null;
         };
 
@@ -792,6 +810,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                     message.environments[keys[i]] = $root.sqlanvil.Environment.fromObject(object.environments[keys[i]], long + 1);
                 }
             }
+            if (object.preserveGovernanceControls != null)
+                message.preserveGovernanceControls = Boolean(object.preserveGovernanceControls);
             return message;
         };
 
@@ -834,6 +854,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.extension = null;
                 object.includeTestsInCompiledGraph = false;
                 object.warehouse = "";
+                object.preserveGovernanceControls = false;
             }
             if (message.sqlanvilCoreVersion != null && Object.hasOwnProperty.call(message, "sqlanvilCoreVersion"))
                 object.sqlanvilCoreVersion = message.sqlanvilCoreVersion;
@@ -892,6 +913,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                     object.environments[keys2[j]] = $root.sqlanvil.Environment.toObject(message.environments[keys2[j]], options, q + 1);
                 }
             }
+            if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                object.preserveGovernanceControls = message.preserveGovernanceControls;
             return object;
         };
 
@@ -4643,6 +4666,7 @@ const sqlanvil = $root.sqlanvil = (() => {
              * @property {sqlanvil.IPostgresOptions|null} [postgres] TableConfig postgres
              * @property {sqlanvil.ISupabaseOptions|null} [supabase] TableConfig supabase
              * @property {sqlanvil.IMysqlOptions|null} [mysql] TableConfig mysql
+             * @property {boolean|null} [preserveGovernanceControls] TableConfig preserveGovernanceControls
              */
 
             /**
@@ -4876,6 +4900,23 @@ const sqlanvil = $root.sqlanvil = (() => {
              */
             TableConfig.prototype.mysql = null;
 
+            /**
+             * TableConfig preserveGovernanceControls.
+             * @member {boolean|null|undefined} preserveGovernanceControls
+             * @memberof sqlanvil.ActionConfig.TableConfig
+             * @instance
+             */
+            TableConfig.prototype.preserveGovernanceControls = null;
+
+            // OneOf field names bound to virtual getters and setters
+            let $oneOfFields;
+
+            // Virtual OneOf for proto3 optional field
+            Object.defineProperty(TableConfig.prototype, "_preserveGovernanceControls", {
+                get: $util.oneOfGetter($oneOfFields = ["preserveGovernanceControls"]),
+                set: $util.oneOfSetter($oneOfFields)
+            });
+
             /**
              * Creates a new TableConfig instance using the specified properties.
              * @function create
@@ -4964,6 +5005,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                     $root.sqlanvil.SupabaseOptions.encode(message.supabase, writer.uint32(/* id 26, wireType 2 =*/210).fork(), q + 1).ldelim();
                 if (message.mysql != null && Object.hasOwnProperty.call(message, "mysql"))
                     $root.sqlanvil.MysqlOptions.encode(message.mysql, writer.uint32(/* id 27, wireType 2 =*/218).fork(), q + 1).ldelim();
+                if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                    writer.uint32(/* id 28, wireType 0 =*/224).bool(message.preserveGovernanceControls);
                 return writer;
             };
 
@@ -5162,6 +5205,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                             message.mysql = $root.sqlanvil.MysqlOptions.decode(reader, reader.uint32(), undefined, long + 1);
                             break;
                         }
+                    case 28: {
+                            message.preserveGovernanceControls = reader.bool();
+                            break;
+                        }
                     default:
                         reader.skipType(tag & 7, long);
                         break;
@@ -5329,6 +5376,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                     if (error)
                         return "mysql." + error;
                 }
+                if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls")) {
+                    if (typeof message.preserveGovernanceControls !== "boolean")
+                        return "preserveGovernanceControls: boolean expected";
+                }
                 return null;
             };
 
@@ -5472,6 +5523,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                         throw TypeError(".sqlanvil.ActionConfig.TableConfig.mysql: object expected");
                     message.mysql = $root.sqlanvil.MysqlOptions.fromObject(object.mysql, long + 1);
                 }
+                if (object.preserveGovernanceControls != null)
+                    message.preserveGovernanceControls = Boolean(object.preserveGovernanceControls);
                 return message;
             };
 
@@ -5607,6 +5660,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                     object.supabase = $root.sqlanvil.SupabaseOptions.toObject(message.supabase, options, q + 1);
                 if (message.mysql != null && Object.hasOwnProperty.call(message, "mysql"))
                     object.mysql = $root.sqlanvil.MysqlOptions.toObject(message.mysql, options, q + 1);
+                if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls")) {
+                    object.preserveGovernanceControls = message.preserveGovernanceControls;
+                    if (options.oneofs)
+                        object._preserveGovernanceControls = "preserveGovernanceControls";
+                }
                 return object;
             };
 
@@ -6862,6 +6920,22 @@ const sqlanvil = $root.sqlanvil = (() => {
             return values;
         })();
 
+        /**
+         * IncrementalStrategy enum.
+         * @name sqlanvil.ActionConfig.IncrementalStrategy
+         * @enum {number}
+         * @property {number} INCREMENTAL_STRATEGY_UNSPECIFIED=0 INCREMENTAL_STRATEGY_UNSPECIFIED value
+         * @property {number} INCREMENTAL_STRATEGY_MERGE=1 INCREMENTAL_STRATEGY_MERGE value
+         * @property {number} INCREMENTAL_STRATEGY_INSERT_OVERWRITE=2 INCREMENTAL_STRATEGY_INSERT_OVERWRITE value
+         */
+        ActionConfig.IncrementalStrategy = (function() {
+            const valuesById = {}, values = Object.create(valuesById);
+            values[valuesById[0] = "INCREMENTAL_STRATEGY_UNSPECIFIED"] = 0;
+            values[valuesById[1] = "INCREMENTAL_STRATEGY_MERGE"] = 1;
+            values[valuesById[2] = "INCREMENTAL_STRATEGY_INSERT_OVERWRITE"] = 2;
+            return values;
+        })();
+
         ActionConfig.IncrementalTableConfig = (function() {
 
             /**
@@ -6898,6 +6972,8 @@ const sqlanvil = $root.sqlanvil = (() => {
              * @property {sqlanvil.IPostgresOptions|null} [postgres] IncrementalTableConfig postgres
              * @property {sqlanvil.ISupabaseOptions|null} [supabase] IncrementalTableConfig supabase
              * @property {sqlanvil.IMysqlOptions|null} [mysql] IncrementalTableConfig mysql
+             * @property {sqlanvil.ActionConfig.IncrementalStrategy|null} [incrementalStrategy] IncrementalTableConfig incrementalStrategy
+             * @property {Array.<string>|null} [incrementalPredicates] IncrementalTableConfig incrementalPredicates
              */
 
             /**
@@ -6918,6 +6994,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 this.clusterBy = [];
                 this.labels = {};
                 this.additionalOptions = {};
+                this.incrementalPredicates = [];
                 if (properties)
                     for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                         if (properties[keys[i]] != null && keys[i] !== "__proto__")
@@ -7164,6 +7241,22 @@ const sqlanvil = $root.sqlanvil = (() => {
              */
             IncrementalTableConfig.prototype.mysql = null;
 
+            /**
+             * IncrementalTableConfig incrementalStrategy.
+             * @member {sqlanvil.ActionConfig.IncrementalStrategy} incrementalStrategy
+             * @memberof sqlanvil.ActionConfig.IncrementalTableConfig
+             * @instance
+             */
+            IncrementalTableConfig.prototype.incrementalStrategy = 0;
+
+            /**
+             * IncrementalTableConfig incrementalPredicates.
+             * @member {Array.<string>} incrementalPredicates
+             * @memberof sqlanvil.ActionConfig.IncrementalTableConfig
+             * @instance
+             */
+            IncrementalTableConfig.prototype.incrementalPredicates = $util.emptyArray;
+
             /**
              * Creates a new IncrementalTableConfig instance using the specified properties.
              * @function create
@@ -7261,6 +7354,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                     $root.sqlanvil.SupabaseOptions.encode(message.supabase, writer.uint32(/* id 29, wireType 2 =*/234).fork(), q + 1).ldelim();
                 if (message.mysql != null && Object.hasOwnProperty.call(message, "mysql"))
                     $root.sqlanvil.MysqlOptions.encode(message.mysql, writer.uint32(/* id 30, wireType 2 =*/242).fork(), q + 1).ldelim();
+                if (message.incrementalStrategy != null && Object.hasOwnProperty.call(message, "incrementalStrategy"))
+                    writer.uint32(/* id 31, wireType 0 =*/248).int32(message.incrementalStrategy);
+                if (message.incrementalPredicates != null && message.incrementalPredicates.length)
+                    for (let i = 0; i < message.incrementalPredicates.length; ++i)
+                        writer.uint32(/* id 32, wireType 2 =*/258).string(message.incrementalPredicates[i]);
                 return writer;
             };
 
@@ -7477,6 +7575,16 @@ const sqlanvil = $root.sqlanvil = (() => {
                             message.mysql = $root.sqlanvil.MysqlOptions.decode(reader, reader.uint32(), undefined, long + 1);
                             break;
                         }
+                    case 31: {
+                            message.incrementalStrategy = reader.int32();
+                            break;
+                        }
+                    case 32: {
+                            if (!(message.incrementalPredicates && message.incrementalPredicates.length))
+                                message.incrementalPredicates = [];
+                            message.incrementalPredicates.push(reader.string());
+                            break;
+                        }
                     default:
                         reader.skipType(tag & 7, long);
                         break;
@@ -7667,6 +7775,22 @@ const sqlanvil = $root.sqlanvil = (() => {
                     if (error)
                         return "mysql." + error;
                 }
+                if (message.incrementalStrategy != null && Object.hasOwnProperty.call(message, "incrementalStrategy"))
+                    switch (message.incrementalStrategy) {
+                    default:
+                        return "incrementalStrategy: enum value expected";
+                    case 0:
+                    case 1:
+                    case 2:
+                        break;
+                    }
+                if (message.incrementalPredicates != null && Object.hasOwnProperty.call(message, "incrementalPredicates")) {
+                    if (!Array.isArray(message.incrementalPredicates))
+                        return "incrementalPredicates: array expected";
+                    for (let i = 0; i < message.incrementalPredicates.length; ++i)
+                        if (!$util.isString(message.incrementalPredicates[i]))
+                            return "incrementalPredicates: string[] expected";
+                }
                 return null;
             };
 
@@ -7845,6 +7969,33 @@ const sqlanvil = $root.sqlanvil = (() => {
                         throw TypeError(".sqlanvil.ActionConfig.IncrementalTableConfig.mysql: object expected");
                     message.mysql = $root.sqlanvil.MysqlOptions.fromObject(object.mysql, long + 1);
                 }
+                switch (object.incrementalStrategy) {
+                default:
+                    if (typeof object.incrementalStrategy === "number") {
+                        message.incrementalStrategy = object.incrementalStrategy;
+                        break;
+                    }
+                    break;
+                case "INCREMENTAL_STRATEGY_UNSPECIFIED":
+                case 0:
+                    message.incrementalStrategy = 0;
+                    break;
+                case "INCREMENTAL_STRATEGY_MERGE":
+                case 1:
+                    message.incrementalStrategy = 1;
+                    break;
+                case "INCREMENTAL_STRATEGY_INSERT_OVERWRITE":
+                case 2:
+                    message.incrementalStrategy = 2;
+                    break;
+                }
+                if (object.incrementalPredicates) {
+                    if (!Array.isArray(object.incrementalPredicates))
+                        throw TypeError(".sqlanvil.ActionConfig.IncrementalTableConfig.incrementalPredicates: array expected");
+                    message.incrementalPredicates = [];
+                    for (let i = 0; i < object.incrementalPredicates.length; ++i)
+                        message.incrementalPredicates[i] = String(object.incrementalPredicates[i]);
+                }
                 return message;
             };
 
@@ -7873,6 +8024,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                     object.uniqueKey = [];
                     object.columns = [];
                     object.clusterBy = [];
+                    object.incrementalPredicates = [];
                 }
                 if (options.objects || options.defaults) {
                     object.labels = {};
@@ -7900,6 +8052,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                     object.postgres = null;
                     object.supabase = null;
                     object.mysql = null;
+                    object.incrementalStrategy = options.enums === String ? "INCREMENTAL_STRATEGY_UNSPECIFIED" : 0;
                 }
                 if (message.name != null && Object.hasOwnProperty.call(message, "name"))
                     object.name = message.name;
@@ -7995,6 +8148,13 @@ const sqlanvil = $root.sqlanvil = (() => {
                     object.supabase = $root.sqlanvil.SupabaseOptions.toObject(message.supabase, options, q + 1);
                 if (message.mysql != null && Object.hasOwnProperty.call(message, "mysql"))
                     object.mysql = $root.sqlanvil.MysqlOptions.toObject(message.mysql, options, q + 1);
+                if (message.incrementalStrategy != null && Object.hasOwnProperty.call(message, "incrementalStrategy"))
+                    object.incrementalStrategy = options.enums === String ? $root.sqlanvil.ActionConfig.IncrementalStrategy[message.incrementalStrategy] === undefined ? message.incrementalStrategy : $root.sqlanvil.ActionConfig.IncrementalStrategy[message.incrementalStrategy] : message.incrementalStrategy;
+                if (message.incrementalPredicates && message.incrementalPredicates.length) {
+                    object.incrementalPredicates = [];
+                    for (let j = 0; j < message.incrementalPredicates.length; ++j)
+                        object.incrementalPredicates[j] = message.incrementalPredicates[j];
+                }
                 return object;
             };
 
@@ -21165,6 +21325,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {boolean|null} [includeTestsInCompiledGraph] ProjectConfig includeTestsInCompiledGraph
          * @property {Object.<string,sqlanvil.IConnectionConfig>|null} [connections] ProjectConfig connections
          * @property {string|null} [warehouseConnection] ProjectConfig warehouseConnection
+         * @property {boolean|null} [preserveGovernanceControls] ProjectConfig preserveGovernanceControls
          */
 
         /**
@@ -21320,6 +21481,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         ProjectConfig.prototype.warehouseConnection = "";
 
+        /**
+         * ProjectConfig preserveGovernanceControls.
+         * @member {boolean} preserveGovernanceControls
+         * @memberof sqlanvil.ProjectConfig
+         * @instance
+         */
+        ProjectConfig.prototype.preserveGovernanceControls = false;
+
         /**
          * Creates a new ProjectConfig instance using the specified properties.
          * @function create
@@ -21386,6 +21555,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 }
             if (message.warehouseConnection != null && Object.hasOwnProperty.call(message, "warehouseConnection"))
                 writer.uint32(/* id 24, wireType 2 =*/194).string(message.warehouseConnection);
+            if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                writer.uint32(/* id 25, wireType 0 =*/200).bool(message.preserveGovernanceControls);
             return writer;
         };
 
@@ -21536,6 +21707,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.warehouseConnection = reader.string();
                         break;
                     }
+                case 25: {
+                        message.preserveGovernanceControls = reader.bool();
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -21642,6 +21817,9 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.warehouseConnection != null && Object.hasOwnProperty.call(message, "warehouseConnection"))
                 if (!$util.isString(message.warehouseConnection))
                     return "warehouseConnection: string expected";
+            if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                if (typeof message.preserveGovernanceControls !== "boolean")
+                    return "preserveGovernanceControls: boolean expected";
             return null;
         };
 
@@ -21721,6 +21899,8 @@ const sqlanvil = $root.sqlanvil = (() => {
             }
             if (object.warehouseConnection != null)
                 message.warehouseConnection = String(object.warehouseConnection);
+            if (object.preserveGovernanceControls != null)
+                message.preserveGovernanceControls = Boolean(object.preserveGovernanceControls);
             return message;
         };
 
@@ -21761,6 +21941,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.defaultReservation = "";
                 object.includeTestsInCompiledGraph = false;
                 object.warehouseConnection = "";
+                object.preserveGovernanceControls = false;
             }
             if (message.warehouse != null && Object.hasOwnProperty.call(message, "warehouse"))
                 object.warehouse = message.warehouse;
@@ -21809,6 +21990,8 @@ const sqlanvil = $root.sqlanvil = (() => {
             }
             if (message.warehouseConnection != null && Object.hasOwnProperty.call(message, "warehouseConnection"))
                 object.warehouseConnection = message.warehouseConnection;
+            if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                object.preserveGovernanceControls = message.preserveGovernanceControls;
             return object;
         };
 
@@ -22553,6 +22736,8 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {sqlanvil.TableFormat|null} [tableFormat] BigQueryOptions tableFormat
          * @property {sqlanvil.FileFormat|null} [fileFormat] BigQueryOptions fileFormat
          * @property {string|null} [storageUri] BigQueryOptions storageUri
+         * @property {Array.<string>|null} [incrementalPredicates] BigQueryOptions incrementalPredicates
+         * @property {boolean|null} [preserveGovernanceControls] BigQueryOptions preserveGovernanceControls
          */
 
         /**
@@ -22567,6 +22752,7 @@ const sqlanvil = $root.sqlanvil = (() => {
             this.clusterBy = [];
             this.labels = {};
             this.additionalOptions = {};
+            this.incrementalPredicates = [];
             if (properties)
                 for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
                     if (properties[keys[i]] != null && keys[i] !== "__proto__")
@@ -22661,6 +22847,22 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         BigQueryOptions.prototype.storageUri = "";
 
+        /**
+         * BigQueryOptions incrementalPredicates.
+         * @member {Array.<string>} incrementalPredicates
+         * @memberof sqlanvil.BigQueryOptions
+         * @instance
+         */
+        BigQueryOptions.prototype.incrementalPredicates = $util.emptyArray;
+
+        /**
+         * BigQueryOptions preserveGovernanceControls.
+         * @member {boolean} preserveGovernanceControls
+         * @memberof sqlanvil.BigQueryOptions
+         * @instance
+         */
+        BigQueryOptions.prototype.preserveGovernanceControls = false;
+
         /**
          * Creates a new BigQueryOptions instance using the specified properties.
          * @function create
@@ -22714,6 +22916,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                 writer.uint32(/* id 10, wireType 0 =*/80).int32(message.fileFormat);
             if (message.storageUri != null && Object.hasOwnProperty.call(message, "storageUri"))
                 writer.uint32(/* id 11, wireType 2 =*/90).string(message.storageUri);
+            if (message.incrementalPredicates != null && message.incrementalPredicates.length)
+                for (let i = 0; i < message.incrementalPredicates.length; ++i)
+                    writer.uint32(/* id 12, wireType 2 =*/98).string(message.incrementalPredicates[i]);
+            if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                writer.uint32(/* id 13, wireType 0 =*/104).bool(message.preserveGovernanceControls);
             return writer;
         };
 
@@ -22842,6 +23049,16 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.storageUri = reader.string();
                         break;
                     }
+                case 12: {
+                        if (!(message.incrementalPredicates && message.incrementalPredicates.length))
+                            message.incrementalPredicates = [];
+                        message.incrementalPredicates.push(reader.string());
+                        break;
+                    }
+                case 13: {
+                        message.preserveGovernanceControls = reader.bool();
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -22938,6 +23155,16 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.storageUri != null && Object.hasOwnProperty.call(message, "storageUri"))
                 if (!$util.isString(message.storageUri))
                     return "storageUri: string expected";
+            if (message.incrementalPredicates != null && Object.hasOwnProperty.call(message, "incrementalPredicates")) {
+                if (!Array.isArray(message.incrementalPredicates))
+                    return "incrementalPredicates: array expected";
+                for (let i = 0; i < message.incrementalPredicates.length; ++i)
+                    if (!$util.isString(message.incrementalPredicates[i]))
+                        return "incrementalPredicates: string[] expected";
+            }
+            if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                if (typeof message.preserveGovernanceControls !== "boolean")
+                    return "preserveGovernanceControls: boolean expected";
             return null;
         };
 
@@ -23030,6 +23257,15 @@ const sqlanvil = $root.sqlanvil = (() => {
             }
             if (object.storageUri != null)
                 message.storageUri = String(object.storageUri);
+            if (object.incrementalPredicates) {
+                if (!Array.isArray(object.incrementalPredicates))
+                    throw TypeError(".sqlanvil.BigQueryOptions.incrementalPredicates: array expected");
+                message.incrementalPredicates = [];
+                for (let i = 0; i < object.incrementalPredicates.length; ++i)
+                    message.incrementalPredicates[i] = String(object.incrementalPredicates[i]);
+            }
+            if (object.preserveGovernanceControls != null)
+                message.preserveGovernanceControls = Boolean(object.preserveGovernanceControls);
             return message;
         };
 
@@ -23050,8 +23286,10 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (q > $util.recursionLimit)
                 throw Error("max depth exceeded");
             let object = {};
-            if (options.arrays || options.defaults)
+            if (options.arrays || options.defaults) {
                 object.clusterBy = [];
+                object.incrementalPredicates = [];
+            }
             if (options.objects || options.defaults) {
                 object.labels = {};
                 object.additionalOptions = {};
@@ -23065,6 +23303,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.tableFormat = options.enums === String ? "TABLE_FORMAT_UNSPECIFIED" : 0;
                 object.fileFormat = options.enums === String ? "FILE_FORMAT_UNSPECIFIED" : 0;
                 object.storageUri = "";
+                object.preserveGovernanceControls = false;
             }
             if (message.partitionBy != null && Object.hasOwnProperty.call(message, "partitionBy"))
                 object.partitionBy = message.partitionBy;
@@ -23104,6 +23343,13 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.fileFormat = options.enums === String ? $root.sqlanvil.FileFormat[message.fileFormat] === undefined ? message.fileFormat : $root.sqlanvil.FileFormat[message.fileFormat] : message.fileFormat;
             if (message.storageUri != null && Object.hasOwnProperty.call(message, "storageUri"))
                 object.storageUri = message.storageUri;
+            if (message.incrementalPredicates && message.incrementalPredicates.length) {
+                object.incrementalPredicates = [];
+                for (let j = 0; j < message.incrementalPredicates.length; ++j)
+                    object.incrementalPredicates[j] = message.incrementalPredicates[j];
+            }
+            if (message.preserveGovernanceControls != null && Object.hasOwnProperty.call(message, "preserveGovernanceControls"))
+                object.preserveGovernanceControls = message.preserveGovernanceControls;
             return object;
         };
 
@@ -24825,6 +25071,22 @@ const sqlanvil = $root.sqlanvil = (() => {
         return values;
     })();
 
+    /**
+     * IncrementalStrategy enum.
+     * @name sqlanvil.IncrementalStrategy
+     * @enum {number}
+     * @property {number} INCREMENTAL_STRATEGY_UNSPECIFIED=0 INCREMENTAL_STRATEGY_UNSPECIFIED value
+     * @property {number} MERGE=1 MERGE value
+     * @property {number} INSERT_OVERWRITE=2 INSERT_OVERWRITE value
+     */
+    sqlanvil.IncrementalStrategy = (function() {
+        const valuesById = {}, values = Object.create(valuesById);
+        values[valuesById[0] = "INCREMENTAL_STRATEGY_UNSPECIFIED"] = 0;
+        values[valuesById[1] = "MERGE"] = 1;
+        values[valuesById[2] = "INSERT_OVERWRITE"] = 2;
+        return values;
+    })();
+
     sqlanvil.Table = (function() {
 
         /**
@@ -24852,6 +25114,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {Array.<string>|null} [incrementalPreOps] Table incrementalPreOps
          * @property {Array.<string>|null} [incrementalPostOps] Table incrementalPostOps
          * @property {string|null} [jitCode] Table jitCode
+         * @property {sqlanvil.IncrementalStrategy|null} [incrementalStrategy] Table incrementalStrategy
          * @property {sqlanvil.IBigQueryOptions|null} [bigquery] Table bigquery
          * @property {sqlanvil.IPostgresOptions|null} [postgres] Table postgres
          * @property {sqlanvil.ISupabaseOptions|null} [supabase] Table supabase
@@ -25049,6 +25312,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         Table.prototype.jitCode = "";
 
+        /**
+         * Table incrementalStrategy.
+         * @member {sqlanvil.IncrementalStrategy} incrementalStrategy
+         * @memberof sqlanvil.Table
+         * @instance
+         */
+        Table.prototype.incrementalStrategy = 0;
+
         /**
          * Table bigquery.
          * @member {sqlanvil.IBigQueryOptions|null|undefined} bigquery
@@ -25176,6 +25447,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 $root.sqlanvil.SupabaseOptions.encode(message.supabase, writer.uint32(/* id 40, wireType 2 =*/322).fork(), q + 1).ldelim();
             if (message.mysql != null && Object.hasOwnProperty.call(message, "mysql"))
                 $root.sqlanvil.MysqlOptions.encode(message.mysql, writer.uint32(/* id 41, wireType 2 =*/330).fork(), q + 1).ldelim();
+            if (message.incrementalStrategy != null && Object.hasOwnProperty.call(message, "incrementalStrategy"))
+                writer.uint32(/* id 42, wireType 0 =*/336).int32(message.incrementalStrategy);
             return writer;
         };
 
@@ -25314,6 +25587,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.jitCode = reader.string();
                         break;
                     }
+                case 42: {
+                        message.incrementalStrategy = reader.int32();
+                        break;
+                    }
                 case 22: {
                         message.bigquery = $root.sqlanvil.BigQueryOptions.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
@@ -25492,6 +25769,15 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.jitCode != null && Object.hasOwnProperty.call(message, "jitCode"))
                 if (!$util.isString(message.jitCode))
                     return "jitCode: string expected";
+            if (message.incrementalStrategy != null && Object.hasOwnProperty.call(message, "incrementalStrategy"))
+                switch (message.incrementalStrategy) {
+                default:
+                    return "incrementalStrategy: enum value expected";
+                case 0:
+                case 1:
+                case 2:
+                    break;
+                }
             if (message.bigquery != null && Object.hasOwnProperty.call(message, "bigquery")) {
                 let error = $root.sqlanvil.BigQueryOptions.verify(message.bigquery, long + 1);
                 if (error)
@@ -25687,6 +25973,26 @@ const sqlanvil = $root.sqlanvil = (() => {
             }
             if (object.jitCode != null)
                 message.jitCode = String(object.jitCode);
+            switch (object.incrementalStrategy) {
+            default:
+                if (typeof object.incrementalStrategy === "number") {
+                    message.incrementalStrategy = object.incrementalStrategy;
+                    break;
+                }
+                break;
+            case "INCREMENTAL_STRATEGY_UNSPECIFIED":
+            case 0:
+                message.incrementalStrategy = 0;
+                break;
+            case "MERGE":
+            case 1:
+                message.incrementalStrategy = 1;
+                break;
+            case "INSERT_OVERWRITE":
+            case 2:
+                message.incrementalStrategy = 2;
+                break;
+            }
             if (object.bigquery != null) {
                 if (!$util.isObject(object.bigquery))
                     throw TypeError(".sqlanvil.Table.bigquery: object expected");
@@ -25758,6 +26064,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.postgres = null;
                 object.supabase = null;
                 object.mysql = null;
+                object.incrementalStrategy = options.enums === String ? "INCREMENTAL_STRATEGY_UNSPECIFIED" : 0;
             }
             if (message.type != null && Object.hasOwnProperty.call(message, "type"))
                 object.type = message.type;
@@ -25832,6 +26139,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.supabase = $root.sqlanvil.SupabaseOptions.toObject(message.supabase, options, q + 1);
             if (message.mysql != null && Object.hasOwnProperty.call(message, "mysql"))
                 object.mysql = $root.sqlanvil.MysqlOptions.toObject(message.mysql, options, q + 1);
+            if (message.incrementalStrategy != null && Object.hasOwnProperty.call(message, "incrementalStrategy"))
+                object.incrementalStrategy = options.enums === String ? $root.sqlanvil.IncrementalStrategy[message.incrementalStrategy] === undefined ? message.incrementalStrategy : $root.sqlanvil.IncrementalStrategy[message.incrementalStrategy] : message.incrementalStrategy;
             return object;
         };
 
@@ -37843,6 +38152,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {boolean|null} [includeDependents] RunConfig includeDependents
          * @property {boolean|null} [fullRefresh] RunConfig fullRefresh
          * @property {number|null} [timeoutMillis] RunConfig timeoutMillis
+         * @property {number|null} [jitTimeoutMillis] RunConfig jitTimeoutMillis
          * @property {boolean|null} [disableSetMetadata] RunConfig disableSetMetadata
          * @property {boolean|null} [useRunCache] RunConfig useRunCache
          */
@@ -37912,6 +38222,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         RunConfig.prototype.timeoutMillis = 0;
 
+        /**
+         * RunConfig jitTimeoutMillis.
+         * @member {number} jitTimeoutMillis
+         * @memberof sqlanvil.RunConfig
+         * @instance
+         */
+        RunConfig.prototype.jitTimeoutMillis = 0;
+
         /**
          * RunConfig disableSetMetadata.
          * @member {boolean} disableSetMetadata
@@ -37972,6 +38290,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 writer.uint32(/* id 8, wireType 0 =*/64).bool(message.useRunCache);
             if (message.disableSetMetadata != null && Object.hasOwnProperty.call(message, "disableSetMetadata"))
                 writer.uint32(/* id 9, wireType 0 =*/72).bool(message.disableSetMetadata);
+            if (message.jitTimeoutMillis != null && Object.hasOwnProperty.call(message, "jitTimeoutMillis"))
+                writer.uint32(/* id 10, wireType 0 =*/80).int32(message.jitTimeoutMillis);
             if (message.includeDependents != null && Object.hasOwnProperty.call(message, "includeDependents"))
                 writer.uint32(/* id 11, wireType 0 =*/88).bool(message.includeDependents);
             return writer;
@@ -38042,6 +38362,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.timeoutMillis = reader.int32();
                         break;
                     }
+                case 10: {
+                        message.jitTimeoutMillis = reader.int32();
+                        break;
+                    }
                 case 9: {
                         message.disableSetMetadata = reader.bool();
                         break;
@@ -38115,6 +38439,9 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.timeoutMillis != null && Object.hasOwnProperty.call(message, "timeoutMillis"))
                 if (!$util.isInteger(message.timeoutMillis))
                     return "timeoutMillis: integer expected";
+            if (message.jitTimeoutMillis != null && Object.hasOwnProperty.call(message, "jitTimeoutMillis"))
+                if (!$util.isInteger(message.jitTimeoutMillis))
+                    return "jitTimeoutMillis: integer expected";
             if (message.disableSetMetadata != null && Object.hasOwnProperty.call(message, "disableSetMetadata"))
                 if (typeof message.disableSetMetadata !== "boolean")
                     return "disableSetMetadata: boolean expected";
@@ -38164,6 +38491,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 message.fullRefresh = Boolean(object.fullRefresh);
             if (object.timeoutMillis != null)
                 message.timeoutMillis = object.timeoutMillis | 0;
+            if (object.jitTimeoutMillis != null)
+                message.jitTimeoutMillis = object.jitTimeoutMillis | 0;
             if (object.disableSetMetadata != null)
                 message.disableSetMetadata = Boolean(object.disableSetMetadata);
             if (object.useRunCache != null)
@@ -38198,6 +38527,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.timeoutMillis = 0;
                 object.useRunCache = false;
                 object.disableSetMetadata = false;
+                object.jitTimeoutMillis = 0;
                 object.includeDependents = false;
             }
             if (message.actions && message.actions.length) {
@@ -38220,6 +38550,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.useRunCache = message.useRunCache;
             if (message.disableSetMetadata != null && Object.hasOwnProperty.call(message, "disableSetMetadata"))
                 object.disableSetMetadata = message.disableSetMetadata;
+            if (message.jitTimeoutMillis != null && Object.hasOwnProperty.call(message, "jitTimeoutMillis"))
+                object.jitTimeoutMillis = message.jitTimeoutMillis;
             if (message.includeDependents != null && Object.hasOwnProperty.call(message, "includeDependents"))
                 object.includeDependents = message.includeDependents;
             return object;
@@ -42358,6 +42690,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {string|null} [errorMessage] TaskResult errorMessage
          * @property {sqlanvil.ITiming|null} [timing] TaskResult timing
          * @property {sqlanvil.IExecutionMetadata|null} [metadata] TaskResult metadata
+         * @property {string|null} [compiledSql] TaskResult compiledSql
          */
 
         /**
@@ -42407,6 +42740,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         TaskResult.prototype.metadata = null;
 
+        /**
+         * TaskResult compiledSql.
+         * @member {string} compiledSql
+         * @memberof sqlanvil.TaskResult
+         * @instance
+         */
+        TaskResult.prototype.compiledSql = "";
+
         /**
          * Creates a new TaskResult instance using the specified properties.
          * @function create
@@ -42443,6 +42784,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 $root.sqlanvil.Timing.encode(message.timing, writer.uint32(/* id 3, wireType 2 =*/26).fork(), q + 1).ldelim();
             if (message.metadata != null && Object.hasOwnProperty.call(message, "metadata"))
                 $root.sqlanvil.ExecutionMetadata.encode(message.metadata, writer.uint32(/* id 4, wireType 2 =*/34).fork(), q + 1).ldelim();
+            if (message.compiledSql != null && Object.hasOwnProperty.call(message, "compiledSql"))
+                writer.uint32(/* id 5, wireType 2 =*/42).string(message.compiledSql);
             return writer;
         };
 
@@ -42499,6 +42842,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.metadata = $root.sqlanvil.ExecutionMetadata.decode(reader, reader.uint32(), undefined, long + 1);
                         break;
                     }
+                case 5: {
+                        message.compiledSql = reader.string();
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -42563,6 +42910,9 @@ const sqlanvil = $root.sqlanvil = (() => {
                 if (error)
                     return "metadata." + error;
             }
+            if (message.compiledSql != null && Object.hasOwnProperty.call(message, "compiledSql"))
+                if (!$util.isString(message.compiledSql))
+                    return "compiledSql: string expected";
             return null;
         };
 
@@ -42628,6 +42978,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                     throw TypeError(".sqlanvil.TaskResult.metadata: object expected");
                 message.metadata = $root.sqlanvil.ExecutionMetadata.fromObject(object.metadata, long + 1);
             }
+            if (object.compiledSql != null)
+                message.compiledSql = String(object.compiledSql);
             return message;
         };
 
@@ -42653,6 +43005,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.errorMessage = "";
                 object.timing = null;
                 object.metadata = null;
+                object.compiledSql = "";
             }
             if (message.status != null && Object.hasOwnProperty.call(message, "status"))
                 object.status = options.enums === String ? $root.sqlanvil.TaskResult.ExecutionStatus[message.status] === undefined ? message.status : $root.sqlanvil.TaskResult.ExecutionStatus[message.status] : message.status;
@@ -42662,6 +43015,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.timing = $root.sqlanvil.Timing.toObject(message.timing, options, q + 1);
             if (message.metadata != null && Object.hasOwnProperty.call(message, "metadata"))
                 object.metadata = $root.sqlanvil.ExecutionMetadata.toObject(message.metadata, options, q + 1);
+            if (message.compiledSql != null && Object.hasOwnProperty.call(message, "compiledSql"))
+                object.compiledSql = message.compiledSql;
             return object;
         };
 
@@ -49519,15 +49874,41 @@ function resolveExportUri(spec, actionName, opts) {
     return `${prefix}/${name}`;
 }
 
+function formatStatement(statement, isLast, modifier) {
+    const lastLineStart = statement.lastIndexOf("\n") + 1;
+    const commentIndex = statement.indexOf("--", lastLineStart);
+    let code;
+    let comment;
+    if (commentIndex === 0) {
+        code = "";
+        comment = statement;
+    }
+    else if (commentIndex > 0) {
+        code = statement.substring(0, commentIndex).trimEnd();
+        comment = statement.substring(commentIndex);
+    }
+    else {
+        code = statement;
+        comment = "";
+    }
+    if (modifier && code.length > 0) {
+        code = modifier(code);
+    }
+    if (!isLast && code.length > 0 && !code.endsWith(";")) {
+        code = code + ";";
+    }
+    if (code.length > 0 && comment.length > 0) {
+        return code + " " + comment;
+    }
+    return code || comment;
+}
 function concatenateQueries(statements, modifier) {
-    return statements
+    const processed = statements
         .filter(statement => !!statement)
         .map(statement => statement.trim())
-        .map(statement => statement.length > 0 && statement.charAt(statement.length - 1) === ";"
-        ? statement.substring(0, statement.length - 1)
-        : statement)
-        .map(statement => (!!modifier ? modifier(statement) : statement))
-        .join("\n;\n");
+        .filter(statement => statement.length > 0);
+    const formattedStatements = processed.map((statement, index) => formatStatement(statement, index === processed.length - 1, modifier));
+    return formattedStatements.join("\n");
 }
 class Tasks {
     constructor() {
@@ -49749,9 +50130,7 @@ from (${query}) as insertions`;
                         this.buildIncrementalSchemaChangeTasks(tasks, table);
                     case sqlanvil.OnSchemaChange.IGNORE:
                     default:
-                        tasks.add(Task.statement(table.uniqueKey && table.uniqueKey.length > 0
-                            ? this.mergeInto(table.target, tableMetadata === null || tableMetadata === void 0 ? void 0 : tableMetadata.fields.map(f => f.name), this.getIncrementalQuery(table), table.uniqueKey, table.bigquery && table.bigquery.updatePartitionFilter)
-                            : this.insertInto(table.target, tableMetadata === null || tableMetadata === void 0 ? void 0 : tableMetadata.fields.map(f => f.name).map(column => `\`${column}\``), this.getIncrementalQuery(table))));
+                        tasks.add(Task.statement(this.getIncrementalDmlStatement(table, (tableMetadata === null || tableMetadata === void 0 ? void 0 : tableMetadata.fields.map(f => f.name)) || [])));
                         break;
                 }
             }
@@ -49988,14 +50367,68 @@ DROP TABLE IF EXISTS ${emptyTempTableName};
         return `
       create or replace view ${this.resolveTarget(target)} as ${query}`;
     }
-    mergeInto(target, columns, query, uniqueKey, updatePartitionFilter) {
+    getIncrementalDmlStatement(table, columns) {
+        const incrementalQuery = this.getIncrementalQuery(table);
+        switch (table.incrementalStrategy) {
+            case sqlanvil.IncrementalStrategy.INSERT_OVERWRITE:
+                return this.insertOverwrite(table.target, columns, incrementalQuery, table.bigquery);
+            case sqlanvil.IncrementalStrategy.MERGE:
+            default:
+                if (table.uniqueKey && table.uniqueKey.length > 0) {
+                    return this.mergeInto(table.target, columns, incrementalQuery, table.uniqueKey, table.bigquery);
+                }
+                return this.insertInto(table.target, columns.map(column => `\`${column}\``), incrementalQuery);
+        }
+    }
+    buildIncrementalPredicatesString(incrementalPredicates) {
+        var _a;
+        const valid = (_a = incrementalPredicates === null || incrementalPredicates === void 0 ? void 0 : incrementalPredicates.filter(p => p.trim() !== "")) !== null && _a !== void 0 ? _a : [];
+        if (valid.length === 0) {
+            return "";
+        }
+        return `and ${valid.map(p => `(${p})`).join(" and ")}`;
+    }
+    insertOverwrite(target, columns, query, bigquery) {
+        const partitionBy = bigquery === null || bigquery === void 0 ? void 0 : bigquery.partitionBy;
+        const updatePartitionFilter = bigquery === null || bigquery === void 0 ? void 0 : bigquery.updatePartitionFilter;
+        const incrementalPredicatesString = this.buildIncrementalPredicatesString(bigquery === null || bigquery === void 0 ? void 0 : bigquery.incrementalPredicates);
+        const stagingTableUnqualified = `staging_table_temp_${this.uniqueIdGenerator()}`;
+        const backtickedColumns = columns.map(column => `\`${column}\``);
+        return `CREATE OR REPLACE TEMP TABLE \`${stagingTableUnqualified}\` AS (
+  ${query}
+);
+
+BEGIN
+  DECLARE partitions_for_replacement DEFAULT (
+    ARRAY(
+      SELECT DISTINCT ${partitionBy}
+      FROM \`${stagingTableUnqualified}\`
+      WHERE ${partitionBy} IS NOT NULL
+    )
+  );
+
+  MERGE ${this.resolveTarget(target)} T
+  USING \`${stagingTableUnqualified}\` S
+  ON FALSE
+  WHEN NOT MATCHED BY SOURCE AND ${partitionBy} IN UNNEST(partitions_for_replacement)${updatePartitionFilter ? ` and T.${updatePartitionFilter}` : ""}${incrementalPredicatesString ? ` ${incrementalPredicatesString}` : ""}
+  THEN
+    DELETE
+  WHEN NOT MATCHED BY TARGET THEN
+    INSERT (${backtickedColumns.join(",")}) VALUES (${backtickedColumns.join(",")});
+END;
+
+DROP TABLE IF EXISTS \`${stagingTableUnqualified}\`;`;
+    }
+    mergeInto(target, columns, query, uniqueKey, bigquery) {
+        const updatePartitionFilter = bigquery === null || bigquery === void 0 ? void 0 : bigquery.updatePartitionFilter;
+        const incrementalPredicatesString = this.buildIncrementalPredicatesString(bigquery === null || bigquery === void 0 ? void 0 : bigquery.incrementalPredicates);
         const backtickedColumns = columns.map(column => `\`${column}\``);
         return `
 merge ${this.resolveTarget(target)} T
 using (${query}
 ) S
 on ${uniqueKey.map(uniqueKeyCol => `T.${uniqueKeyCol} = S.${uniqueKeyCol}`).join(` and `)}
-  ${updatePartitionFilter ? `and T.${updatePartitionFilter}` : ""}
+  ${updatePartitionFilter ? `and T.${updatePartitionFilter}` : ""}${incrementalPredicatesString ? `\n  ${incrementalPredicatesString}` : ""}
 when matched then
   update set ${columns.map(column => `\`${column}\` = S.${column}`).join(",")}
 when not matched then
@@ -50646,8 +51079,8 @@ function collectEvaluationQueries(queryOrAction, concatenate, queryModifier = (q
         .filter(validationQuery => !!validationQuery.query);
 }
 
-const version = "1.27.2";
-const dataformVersion = "3.0.61";
+const version = "1.29.0";
+const dataformVersion = "3.0.62";
 
 async function build(compiledGraph, runConfig, dbadapter) {
     const prunedGraph = prune(compiledGraph, runConfig);
@@ -51496,13 +51929,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 +53023,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 +53070,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 +53081,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(", ")}`, {
@@ -53560,7 +54013,7 @@ const flags = {
 };
 const isSuccessfulAction = (actionResult) => actionResult.status === sqlanvil.ActionResult.ExecutionStatus.SUCCESSFUL ||
     actionResult.status === sqlanvil.ActionResult.ExecutionStatus.DISABLED;
-function run(dbadapter, graph, executionOptions, partiallyExecutedRunResult = {}, runnerNotificationPeriodMillis = flags.runnerNotificationPeriodMillis.get()) {
+function run(dbadapter, graph, executionOptions = {}, partiallyExecutedRunResult = {}, runnerNotificationPeriodMillis = flags.runnerNotificationPeriodMillis.get()) {
     return new Runner(dbadapter, graph, executionOptions, partiallyExecutedRunResult, runnerNotificationPeriodMillis).execute();
 }
 class Runner {
@@ -53568,17 +54021,18 @@ class Runner {
         var _a;
         this.dbadapter = dbadapter;
         this.graph = graph;
-        this.executionOptions = executionOptions;
         this.runnerNotificationPeriodMillis = runnerNotificationPeriodMillis;
         this.changeListeners = [];
         this.lastNotificationTimestampMillis = 0;
         this.stopped = false;
         this.cancelled = false;
         this.timedOut = false;
+        this.skipReason = "";
         this.runningExtracts = 0;
         this.extractWaiters = [];
-        this.allActionTargets = new Set(graph.actions.map(action => targetStringifier.stringify(action.target)));
+        this.executionOptions = Object.assign({ projectDir: "." }, executionOptions);
         this.runResult = Object.assign({ actions: [] }, partiallyExecutedRunResult);
+        this.allActionTargets = new Set(graph.actions.map(action => targetStringifier.stringify(action.target)));
         this.warehouseStateByTarget = new Map();
         (_a = graph.warehouseState.tables) === null || _a === void 0 ? void 0 : _a.forEach(tableMetadata => this.warehouseStateByTarget.set(targetStringifier.stringify(tableMetadata.target), tableMetadata));
         this.executedActionTargets = new Set(this.runResult.actions
@@ -53591,6 +54045,12 @@ class Runner {
         this.eEmitter = new EventEmitter__default["default"]();
         this.eEmitter.setMaxListeners(0);
     }
+    static create(dbadapter, graph, options = {}, runnerNotificationPeriodMillis = flags.runnerNotificationPeriodMillis.get()) {
+        return new Runner(dbadapter, graph, options, {}, runnerNotificationPeriodMillis);
+    }
+    static resume(dbadapter, graph, runResult, runnerNotificationPeriodMillis = flags.runnerNotificationPeriodMillis.get()) {
+        return new Runner(dbadapter, graph, {}, runResult, runnerNotificationPeriodMillis);
+    }
     async acquireExtractSlot() {
         if (this.runningExtracts < Runner.MAX_CONCURRENT_EXTRACTS) {
             this.runningExtracts++;
@@ -53623,7 +54083,7 @@ class Runner {
             const timeoutMillis = this.graph.runConfig.timeoutMillis - elapsedTimeMillis;
             this.timeout = setTimeout(() => {
                 this.timedOut = true;
-                this.cancel();
+                this.cancel("timeout");
             }, timeoutMillis);
         }
         return this;
@@ -53631,7 +54091,22 @@ class Runner {
     stop() {
         this.stopped = true;
     }
-    cancel() {
+    cancel(reason = "user") {
+        var _a;
+        if (!this.skipReason) {
+            switch (reason) {
+                case "timeout":
+                    this.skipReason = ((_a = this.graph.runConfig) === null || _a === void 0 ? void 0 : _a.timeoutMillis) ? `Run timed out after ${this.graph.runConfig.timeoutMillis / 1000} seconds`
+                        : "Run timed out";
+                    break;
+                case "user":
+                    this.skipReason = "Run cancelled";
+                    break;
+                case "cancellation":
+                    this.skipReason = "Run cancelled before action started";
+                    break;
+            }
+        }
         this.cancelled = true;
         this.eEmitter.emit(CANCEL_EVENT, undefined, undefined);
     }
@@ -53703,13 +54178,26 @@ class Runner {
         if (this.cancelled) {
             const allPendingActions = this.pendingActions;
             this.pendingActions = [];
-            allPendingActions.forEach(pendingAction => this.runResult.actions.push({
-                target: pendingAction.target,
-                status: sqlanvil.ActionResult.ExecutionStatus.SKIPPED,
-                tasks: pendingAction.tasks.map(() => ({
-                    status: sqlanvil.TaskResult.ExecutionStatus.SKIPPED
-                }))
-            }));
+            const skipErrorMessage = this.skipReason || "Run cancelled before action started";
+            allPendingActions.forEach(pendingAction => {
+                let tasks;
+                if (pendingAction.tasks && pendingAction.tasks.length > 0) {
+                    tasks = pendingAction.tasks.map((_, i) => (Object.assign({ status: sqlanvil.TaskResult.ExecutionStatus.SKIPPED }, (i === 0 ? { errorMessage: skipErrorMessage } : {}))));
+                }
+                else {
+                    tasks = [
+                        {
+                            status: sqlanvil.TaskResult.ExecutionStatus.SKIPPED,
+                            errorMessage: skipErrorMessage
+                        }
+                    ];
+                }
+                this.runResult.actions.push({
+                    target: pendingAction.target,
+                    status: sqlanvil.ActionResult.ExecutionStatus.SKIPPED,
+                    tasks
+                });
+            });
             this.notifyListeners();
             return;
         }
@@ -53805,7 +54293,8 @@ class Runner {
                 }
                 else {
                     actionResult.tasks.push({
-                        status: sqlanvil.TaskResult.ExecutionStatus.SKIPPED
+                        status: sqlanvil.TaskResult.ExecutionStatus.SKIPPED,
+                        errorMessage: this.skipReason || "Task skipped after cancellation"
                     });
                 }
             }
@@ -54493,6 +54982,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));
@@ -54623,6 +55505,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,
@@ -54632,12 +55700,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",
@@ -54650,32 +55712,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",
@@ -54712,10 +55792,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;
@@ -54780,15 +56244,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);
                 }
@@ -54864,6 +56329,8 @@ async function migrateDataform(opts) {
         files: [],
         skippedForSafety: [],
         warnings: [],
+        todo: [],
+        applied: [],
     };
     const sqlxFiles = [];
     for (const rel of files) {
@@ -55095,6 +56562,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;
@@ -55156,6 +56625,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("");
@@ -55217,6 +56751,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)));
 }
@@ -58354,6 +60336,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;
+                }
             }
         ]
     })