@sqlanvil/cli 1.9.0 → 1.11.0

package/bundle.js

@@ -29,6 +29,7 @@ var childProcess = require('child_process');
 var fs = require('fs-extra');
 var tmp = require('tmp');
 var util = require('util');
+var mysql = require('mysql2/promise');
 var pg = require('pg');
 var bigquery = require('@google-cloud/bigquery');
 var EventEmitter = require('events');
@@ -36,7 +37,6 @@ var Long = require('long');
 var os = require('os');
 var promisePoolExecutor = require('promise-pool-executor');
 var sizeof = require('object-sizeof');
-var mysql = require('mysql2/promise');
 var QueryStream = require('pg-query-stream');
 var readlineSync = require('readline-sync');
 var untildify = require('untildify');
@@ -76,12 +76,12 @@ var semver__namespace = /*#__PURE__*/_interopNamespace(semver);
 var childProcess__namespace = /*#__PURE__*/_interopNamespace(childProcess);
 var fs__namespace = /*#__PURE__*/_interopNamespace(fs);
 var tmp__namespace = /*#__PURE__*/_interopNamespace(tmp);
+var mysql__namespace = /*#__PURE__*/_interopNamespace(mysql);
 var pg__namespace = /*#__PURE__*/_interopNamespace(pg);
 var EventEmitter__default = /*#__PURE__*/_interopDefaultLegacy(EventEmitter);
 var Long__default = /*#__PURE__*/_interopDefaultLegacy(Long);
 var os__namespace = /*#__PURE__*/_interopNamespace(os);
 var sizeof__default = /*#__PURE__*/_interopDefaultLegacy(sizeof);
-var mysql__namespace = /*#__PURE__*/_interopNamespace(mysql);
 var QueryStream__default = /*#__PURE__*/_interopDefaultLegacy(QueryStream);
 var readlineSync__namespace = /*#__PURE__*/_interopNamespace(readlineSync);
 var untildify__default = /*#__PURE__*/_interopDefaultLegacy(untildify);
@@ -15249,6 +15249,7 @@ const sqlanvil = $root.sqlanvil = (() => {
          * @property {string|null} [charset] MysqlOptions charset
          * @property {string|null} [collation] MysqlOptions collation
          * @property {Array.<sqlanvil.MysqlOptions.IIndex>|null} [indexes] MysqlOptions indexes
+         * @property {sqlanvil.MysqlOptions.IPartition|null} [partition] MysqlOptions partition
          */
 
         /**
@@ -15299,6 +15300,14 @@ const sqlanvil = $root.sqlanvil = (() => {
          */
         MysqlOptions.prototype.indexes = $util.emptyArray;
 
+        /**
+         * MysqlOptions partition.
+         * @member {sqlanvil.MysqlOptions.IPartition|null|undefined} partition
+         * @memberof sqlanvil.MysqlOptions
+         * @instance
+         */
+        MysqlOptions.prototype.partition = null;
+
         /**
          * Creates a new MysqlOptions instance using the specified properties.
          * @function create
@@ -15332,6 +15341,8 @@ const sqlanvil = $root.sqlanvil = (() => {
             if (message.indexes != null && message.indexes.length)
                 for (let i = 0; i < message.indexes.length; ++i)
                     $root.sqlanvil.MysqlOptions.Index.encode(message.indexes[i], writer.uint32(/* id 4, wireType 2 =*/34).fork()).ldelim();
+            if (message.partition != null && Object.hasOwnProperty.call(message, "partition"))
+                $root.sqlanvil.MysqlOptions.Partition.encode(message.partition, writer.uint32(/* id 5, wireType 2 =*/42).fork()).ldelim();
             return writer;
         };
 
@@ -15390,6 +15401,10 @@ const sqlanvil = $root.sqlanvil = (() => {
                         message.indexes.push($root.sqlanvil.MysqlOptions.Index.decode(reader, reader.uint32(), undefined, long + 1));
                         break;
                     }
+                case 5: {
+                        message.partition = $root.sqlanvil.MysqlOptions.Partition.decode(reader, reader.uint32(), undefined, long + 1);
+                        break;
+                    }
                 default:
                     reader.skipType(tag & 7, long);
                     break;
@@ -15447,6 +15462,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                         return "indexes." + error;
                 }
             }
+            if (message.partition != null && message.hasOwnProperty("partition")) {
+                let error = $root.sqlanvil.MysqlOptions.Partition.verify(message.partition, long + 1);
+                if (error)
+                    return "partition." + error;
+            }
             return null;
         };
 
@@ -15482,6 +15502,11 @@ const sqlanvil = $root.sqlanvil = (() => {
                     message.indexes[i] = $root.sqlanvil.MysqlOptions.Index.fromObject(object.indexes[i], long + 1);
                 }
             }
+            if (object.partition != null) {
+                if (typeof object.partition !== "object")
+                    throw TypeError(".sqlanvil.MysqlOptions.partition: object expected");
+                message.partition = $root.sqlanvil.MysqlOptions.Partition.fromObject(object.partition, long + 1);
+            }
             return message;
         };
 
@@ -15504,6 +15529,7 @@ const sqlanvil = $root.sqlanvil = (() => {
                 object.engine = "";
                 object.charset = "";
                 object.collation = "";
+                object.partition = null;
             }
             if (message.engine != null && message.hasOwnProperty("engine"))
                 object.engine = message.engine;
@@ -15516,6 +15542,8 @@ const sqlanvil = $root.sqlanvil = (() => {
                 for (let j = 0; j < message.indexes.length; ++j)
                     object.indexes[j] = $root.sqlanvil.MysqlOptions.Index.toObject(message.indexes[j], options);
             }
+            if (message.partition != null && message.hasOwnProperty("partition"))
+                object.partition = $root.sqlanvil.MysqlOptions.Partition.toObject(message.partition, options);
             return object;
         };
 
@@ -15826,6 +15854,603 @@ const sqlanvil = $root.sqlanvil = (() => {
             return Index;
         })();
 
+        MysqlOptions.Partition = (function() {
+
+            /**
+             * Properties of a Partition.
+             * @memberof sqlanvil.MysqlOptions
+             * @interface IPartition
+             * @property {sqlanvil.MysqlOptions.Partition.Kind|null} [kind] Partition kind
+             * @property {string|null} [expression] Partition expression
+             * @property {Array.<sqlanvil.MysqlOptions.Partition.IBound>|null} [partitions] Partition partitions
+             * @property {number|null} [count] Partition count
+             */
+
+            /**
+             * Constructs a new Partition.
+             * @memberof sqlanvil.MysqlOptions
+             * @classdesc Represents a Partition.
+             * @implements IPartition
+             * @constructor
+             * @param {sqlanvil.MysqlOptions.IPartition=} [properties] Properties to set
+             */
+            function Partition(properties) {
+                this.partitions = [];
+                if (properties)
+                    for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                        if (properties[keys[i]] != null && keys[i] !== "__proto__")
+                            this[keys[i]] = properties[keys[i]];
+            }
+
+            /**
+             * Partition kind.
+             * @member {sqlanvil.MysqlOptions.Partition.Kind} kind
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @instance
+             */
+            Partition.prototype.kind = 0;
+
+            /**
+             * Partition expression.
+             * @member {string} expression
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @instance
+             */
+            Partition.prototype.expression = "";
+
+            /**
+             * Partition partitions.
+             * @member {Array.<sqlanvil.MysqlOptions.Partition.IBound>} partitions
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @instance
+             */
+            Partition.prototype.partitions = $util.emptyArray;
+
+            /**
+             * Partition count.
+             * @member {number} count
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @instance
+             */
+            Partition.prototype.count = 0;
+
+            /**
+             * Creates a new Partition instance using the specified properties.
+             * @function create
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @static
+             * @param {sqlanvil.MysqlOptions.IPartition=} [properties] Properties to set
+             * @returns {sqlanvil.MysqlOptions.Partition} Partition instance
+             */
+            Partition.create = function create(properties) {
+                return new Partition(properties);
+            };
+
+            /**
+             * Encodes the specified Partition message. Does not implicitly {@link sqlanvil.MysqlOptions.Partition.verify|verify} messages.
+             * @function encode
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @static
+             * @param {sqlanvil.MysqlOptions.IPartition} message Partition message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            Partition.encode = function encode(message, writer) {
+                if (!writer)
+                    writer = $Writer.create();
+                if (message.kind != null && Object.hasOwnProperty.call(message, "kind"))
+                    writer.uint32(/* id 1, wireType 0 =*/8).int32(message.kind);
+                if (message.expression != null && Object.hasOwnProperty.call(message, "expression"))
+                    writer.uint32(/* id 2, wireType 2 =*/18).string(message.expression);
+                if (message.partitions != null && message.partitions.length)
+                    for (let i = 0; i < message.partitions.length; ++i)
+                        $root.sqlanvil.MysqlOptions.Partition.Bound.encode(message.partitions[i], writer.uint32(/* id 3, wireType 2 =*/26).fork()).ldelim();
+                if (message.count != null && Object.hasOwnProperty.call(message, "count"))
+                    writer.uint32(/* id 4, wireType 0 =*/32).uint32(message.count);
+                return writer;
+            };
+
+            /**
+             * Encodes the specified Partition message, length delimited. Does not implicitly {@link sqlanvil.MysqlOptions.Partition.verify|verify} messages.
+             * @function encodeDelimited
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @static
+             * @param {sqlanvil.MysqlOptions.IPartition} message Partition message or plain object to encode
+             * @param {$protobuf.Writer} [writer] Writer to encode to
+             * @returns {$protobuf.Writer} Writer
+             */
+            Partition.encodeDelimited = function encodeDelimited(message, writer) {
+                return this.encode(message, writer).ldelim();
+            };
+
+            /**
+             * Decodes a Partition message from the specified reader or buffer.
+             * @function decode
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @param {number} [length] Message length if known beforehand
+             * @returns {sqlanvil.MysqlOptions.Partition} Partition
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            Partition.decode = function decode(reader, length, error, long) {
+                if (!(reader instanceof $Reader))
+                    reader = $Reader.create(reader);
+                if (long === undefined)
+                    long = 0;
+                if (long > $Reader.recursionLimit)
+                    throw Error("maximum nesting depth exceeded");
+                let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sqlanvil.MysqlOptions.Partition();
+                while (reader.pos < end) {
+                    let tag = reader.uint32();
+                    if (tag === error)
+                        break;
+                    switch (tag >>> 3) {
+                    case 1: {
+                            message.kind = reader.int32();
+                            break;
+                        }
+                    case 2: {
+                            message.expression = reader.string();
+                            break;
+                        }
+                    case 3: {
+                            if (!(message.partitions && message.partitions.length))
+                                message.partitions = [];
+                            message.partitions.push($root.sqlanvil.MysqlOptions.Partition.Bound.decode(reader, reader.uint32(), undefined, long + 1));
+                            break;
+                        }
+                    case 4: {
+                            message.count = reader.uint32();
+                            break;
+                        }
+                    default:
+                        reader.skipType(tag & 7, long);
+                        break;
+                    }
+                }
+                return message;
+            };
+
+            /**
+             * Decodes a Partition message from the specified reader or buffer, length delimited.
+             * @function decodeDelimited
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @static
+             * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+             * @returns {sqlanvil.MysqlOptions.Partition} Partition
+             * @throws {Error} If the payload is not a reader or valid buffer
+             * @throws {$protobuf.util.ProtocolError} If required fields are missing
+             */
+            Partition.decodeDelimited = function decodeDelimited(reader) {
+                if (!(reader instanceof $Reader))
+                    reader = new $Reader(reader);
+                return this.decode(reader, reader.uint32());
+            };
+
+            /**
+             * Verifies a Partition message.
+             * @function verify
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @static
+             * @param {Object.<string,*>} message Plain object to verify
+             * @returns {string|null} `null` if valid, otherwise the reason why it is not
+             */
+            Partition.verify = function verify(message, long) {
+                if (typeof message !== "object" || message === null)
+                    return "object expected";
+                if (long === undefined)
+                    long = 0;
+                if (long > $util.recursionLimit)
+                    return "maximum nesting depth exceeded";
+                if (message.kind != null && message.hasOwnProperty("kind"))
+                    switch (message.kind) {
+                    default:
+                        return "kind: enum value expected";
+                    case 0:
+                    case 1:
+                    case 2:
+                    case 3:
+                        break;
+                    }
+                if (message.expression != null && message.hasOwnProperty("expression"))
+                    if (!$util.isString(message.expression))
+                        return "expression: string expected";
+                if (message.partitions != null && message.hasOwnProperty("partitions")) {
+                    if (!Array.isArray(message.partitions))
+                        return "partitions: array expected";
+                    for (let i = 0; i < message.partitions.length; ++i) {
+                        let error = $root.sqlanvil.MysqlOptions.Partition.Bound.verify(message.partitions[i], long + 1);
+                        if (error)
+                            return "partitions." + error;
+                    }
+                }
+                if (message.count != null && message.hasOwnProperty("count"))
+                    if (!$util.isInteger(message.count))
+                        return "count: integer expected";
+                return null;
+            };
+
+            /**
+             * Creates a Partition message from a plain object. Also converts values to their respective internal types.
+             * @function fromObject
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @static
+             * @param {Object.<string,*>} object Plain object
+             * @returns {sqlanvil.MysqlOptions.Partition} Partition
+             */
+            Partition.fromObject = function fromObject(object, long) {
+                if (object instanceof $root.sqlanvil.MysqlOptions.Partition)
+                    return object;
+                if (long === undefined)
+                    long = 0;
+                if (long > $util.recursionLimit)
+                    throw Error("maximum nesting depth exceeded");
+                let message = new $root.sqlanvil.MysqlOptions.Partition();
+                switch (object.kind) {
+                default:
+                    if (typeof object.kind === "number") {
+                        message.kind = object.kind;
+                        break;
+                    }
+                    break;
+                case "RANGE":
+                case 0:
+                    message.kind = 0;
+                    break;
+                case "LIST":
+                case 1:
+                    message.kind = 1;
+                    break;
+                case "HASH":
+                case 2:
+                    message.kind = 2;
+                    break;
+                case "KEY":
+                case 3:
+                    message.kind = 3;
+                    break;
+                }
+                if (object.expression != null)
+                    message.expression = String(object.expression);
+                if (object.partitions) {
+                    if (!Array.isArray(object.partitions))
+                        throw TypeError(".sqlanvil.MysqlOptions.Partition.partitions: array expected");
+                    message.partitions = [];
+                    for (let i = 0; i < object.partitions.length; ++i) {
+                        if (typeof object.partitions[i] !== "object")
+                            throw TypeError(".sqlanvil.MysqlOptions.Partition.partitions: object expected");
+                        message.partitions[i] = $root.sqlanvil.MysqlOptions.Partition.Bound.fromObject(object.partitions[i], long + 1);
+                    }
+                }
+                if (object.count != null)
+                    message.count = object.count >>> 0;
+                return message;
+            };
+
+            /**
+             * Creates a plain object from a Partition message. Also converts values to other types if specified.
+             * @function toObject
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @static
+             * @param {sqlanvil.MysqlOptions.Partition} message Partition
+             * @param {$protobuf.IConversionOptions} [options] Conversion options
+             * @returns {Object.<string,*>} Plain object
+             */
+            Partition.toObject = function toObject(message, options) {
+                if (!options)
+                    options = {};
+                let object = {};
+                if (options.arrays || options.defaults)
+                    object.partitions = [];
+                if (options.defaults) {
+                    object.kind = options.enums === String ? "RANGE" : 0;
+                    object.expression = "";
+                    object.count = 0;
+                }
+                if (message.kind != null && message.hasOwnProperty("kind"))
+                    object.kind = options.enums === String ? $root.sqlanvil.MysqlOptions.Partition.Kind[message.kind] === undefined ? message.kind : $root.sqlanvil.MysqlOptions.Partition.Kind[message.kind] : message.kind;
+                if (message.expression != null && message.hasOwnProperty("expression"))
+                    object.expression = message.expression;
+                if (message.partitions && message.partitions.length) {
+                    object.partitions = [];
+                    for (let j = 0; j < message.partitions.length; ++j)
+                        object.partitions[j] = $root.sqlanvil.MysqlOptions.Partition.Bound.toObject(message.partitions[j], options);
+                }
+                if (message.count != null && message.hasOwnProperty("count"))
+                    object.count = message.count;
+                return object;
+            };
+
+            /**
+             * Converts this Partition to JSON.
+             * @function toJSON
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @instance
+             * @returns {Object.<string,*>} JSON object
+             */
+            Partition.prototype.toJSON = function toJSON() {
+                return this.constructor.toObject(this, $protobuf__namespace.util.toJSONOptions);
+            };
+
+            /**
+             * Gets the default type url for Partition
+             * @function getTypeUrl
+             * @memberof sqlanvil.MysqlOptions.Partition
+             * @static
+             * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+             * @returns {string} The default type url
+             */
+            Partition.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+                if (typeUrlPrefix === undefined) {
+                    typeUrlPrefix = "type.googleapis.com";
+                }
+                return typeUrlPrefix + "/sqlanvil.MysqlOptions.Partition";
+            };
+
+            /**
+             * Kind enum.
+             * @name sqlanvil.MysqlOptions.Partition.Kind
+             * @enum {number}
+             * @property {number} RANGE=0 RANGE value
+             * @property {number} LIST=1 LIST value
+             * @property {number} HASH=2 HASH value
+             * @property {number} KEY=3 KEY value
+             */
+            Partition.Kind = (function() {
+                const valuesById = {}, values = Object.create(valuesById);
+                values[valuesById[0] = "RANGE"] = 0;
+                values[valuesById[1] = "LIST"] = 1;
+                values[valuesById[2] = "HASH"] = 2;
+                values[valuesById[3] = "KEY"] = 3;
+                return values;
+            })();
+
+            Partition.Bound = (function() {
+
+                /**
+                 * Properties of a Bound.
+                 * @memberof sqlanvil.MysqlOptions.Partition
+                 * @interface IBound
+                 * @property {string|null} [name] Bound name
+                 * @property {string|null} [values] Bound values
+                 */
+
+                /**
+                 * Constructs a new Bound.
+                 * @memberof sqlanvil.MysqlOptions.Partition
+                 * @classdesc Represents a Bound.
+                 * @implements IBound
+                 * @constructor
+                 * @param {sqlanvil.MysqlOptions.Partition.IBound=} [properties] Properties to set
+                 */
+                function Bound(properties) {
+                    if (properties)
+                        for (let keys = Object.keys(properties), i = 0; i < keys.length; ++i)
+                            if (properties[keys[i]] != null && keys[i] !== "__proto__")
+                                this[keys[i]] = properties[keys[i]];
+                }
+
+                /**
+                 * Bound name.
+                 * @member {string} name
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @instance
+                 */
+                Bound.prototype.name = "";
+
+                /**
+                 * Bound values.
+                 * @member {string} values
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @instance
+                 */
+                Bound.prototype.values = "";
+
+                /**
+                 * Creates a new Bound instance using the specified properties.
+                 * @function create
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @static
+                 * @param {sqlanvil.MysqlOptions.Partition.IBound=} [properties] Properties to set
+                 * @returns {sqlanvil.MysqlOptions.Partition.Bound} Bound instance
+                 */
+                Bound.create = function create(properties) {
+                    return new Bound(properties);
+                };
+
+                /**
+                 * Encodes the specified Bound message. Does not implicitly {@link sqlanvil.MysqlOptions.Partition.Bound.verify|verify} messages.
+                 * @function encode
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @static
+                 * @param {sqlanvil.MysqlOptions.Partition.IBound} message Bound message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                Bound.encode = function encode(message, writer) {
+                    if (!writer)
+                        writer = $Writer.create();
+                    if (message.name != null && Object.hasOwnProperty.call(message, "name"))
+                        writer.uint32(/* id 1, wireType 2 =*/10).string(message.name);
+                    if (message.values != null && Object.hasOwnProperty.call(message, "values"))
+                        writer.uint32(/* id 2, wireType 2 =*/18).string(message.values);
+                    return writer;
+                };
+
+                /**
+                 * Encodes the specified Bound message, length delimited. Does not implicitly {@link sqlanvil.MysqlOptions.Partition.Bound.verify|verify} messages.
+                 * @function encodeDelimited
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @static
+                 * @param {sqlanvil.MysqlOptions.Partition.IBound} message Bound message or plain object to encode
+                 * @param {$protobuf.Writer} [writer] Writer to encode to
+                 * @returns {$protobuf.Writer} Writer
+                 */
+                Bound.encodeDelimited = function encodeDelimited(message, writer) {
+                    return this.encode(message, writer).ldelim();
+                };
+
+                /**
+                 * Decodes a Bound message from the specified reader or buffer.
+                 * @function decode
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @param {number} [length] Message length if known beforehand
+                 * @returns {sqlanvil.MysqlOptions.Partition.Bound} Bound
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                Bound.decode = function decode(reader, length, error, long) {
+                    if (!(reader instanceof $Reader))
+                        reader = $Reader.create(reader);
+                    if (long === undefined)
+                        long = 0;
+                    if (long > $Reader.recursionLimit)
+                        throw Error("maximum nesting depth exceeded");
+                    let end = length === undefined ? reader.len : reader.pos + length, message = new $root.sqlanvil.MysqlOptions.Partition.Bound();
+                    while (reader.pos < end) {
+                        let tag = reader.uint32();
+                        if (tag === error)
+                            break;
+                        switch (tag >>> 3) {
+                        case 1: {
+                                message.name = reader.string();
+                                break;
+                            }
+                        case 2: {
+                                message.values = reader.string();
+                                break;
+                            }
+                        default:
+                            reader.skipType(tag & 7, long);
+                            break;
+                        }
+                    }
+                    return message;
+                };
+
+                /**
+                 * Decodes a Bound message from the specified reader or buffer, length delimited.
+                 * @function decodeDelimited
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @static
+                 * @param {$protobuf.Reader|Uint8Array} reader Reader or buffer to decode from
+                 * @returns {sqlanvil.MysqlOptions.Partition.Bound} Bound
+                 * @throws {Error} If the payload is not a reader or valid buffer
+                 * @throws {$protobuf.util.ProtocolError} If required fields are missing
+                 */
+                Bound.decodeDelimited = function decodeDelimited(reader) {
+                    if (!(reader instanceof $Reader))
+                        reader = new $Reader(reader);
+                    return this.decode(reader, reader.uint32());
+                };
+
+                /**
+                 * Verifies a Bound message.
+                 * @function verify
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @static
+                 * @param {Object.<string,*>} message Plain object to verify
+                 * @returns {string|null} `null` if valid, otherwise the reason why it is not
+                 */
+                Bound.verify = function verify(message, long) {
+                    if (typeof message !== "object" || message === null)
+                        return "object expected";
+                    if (long === undefined)
+                        long = 0;
+                    if (long > $util.recursionLimit)
+                        return "maximum nesting depth exceeded";
+                    if (message.name != null && message.hasOwnProperty("name"))
+                        if (!$util.isString(message.name))
+                            return "name: string expected";
+                    if (message.values != null && message.hasOwnProperty("values"))
+                        if (!$util.isString(message.values))
+                            return "values: string expected";
+                    return null;
+                };
+
+                /**
+                 * Creates a Bound message from a plain object. Also converts values to their respective internal types.
+                 * @function fromObject
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @static
+                 * @param {Object.<string,*>} object Plain object
+                 * @returns {sqlanvil.MysqlOptions.Partition.Bound} Bound
+                 */
+                Bound.fromObject = function fromObject(object, long) {
+                    if (object instanceof $root.sqlanvil.MysqlOptions.Partition.Bound)
+                        return object;
+                    if (long === undefined)
+                        long = 0;
+                    if (long > $util.recursionLimit)
+                        throw Error("maximum nesting depth exceeded");
+                    let message = new $root.sqlanvil.MysqlOptions.Partition.Bound();
+                    if (object.name != null)
+                        message.name = String(object.name);
+                    if (object.values != null)
+                        message.values = String(object.values);
+                    return message;
+                };
+
+                /**
+                 * Creates a plain object from a Bound message. Also converts values to other types if specified.
+                 * @function toObject
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @static
+                 * @param {sqlanvil.MysqlOptions.Partition.Bound} message Bound
+                 * @param {$protobuf.IConversionOptions} [options] Conversion options
+                 * @returns {Object.<string,*>} Plain object
+                 */
+                Bound.toObject = function toObject(message, options) {
+                    if (!options)
+                        options = {};
+                    let object = {};
+                    if (options.defaults) {
+                        object.name = "";
+                        object.values = "";
+                    }
+                    if (message.name != null && message.hasOwnProperty("name"))
+                        object.name = message.name;
+                    if (message.values != null && message.hasOwnProperty("values"))
+                        object.values = message.values;
+                    return object;
+                };
+
+                /**
+                 * Converts this Bound to JSON.
+                 * @function toJSON
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @instance
+                 * @returns {Object.<string,*>} JSON object
+                 */
+                Bound.prototype.toJSON = function toJSON() {
+                    return this.constructor.toObject(this, $protobuf__namespace.util.toJSONOptions);
+                };
+
+                /**
+                 * Gets the default type url for Bound
+                 * @function getTypeUrl
+                 * @memberof sqlanvil.MysqlOptions.Partition.Bound
+                 * @static
+                 * @param {string} [typeUrlPrefix] your custom typeUrlPrefix(default "type.googleapis.com")
+                 * @returns {string} The default type url
+                 */
+                Bound.getTypeUrl = function getTypeUrl(typeUrlPrefix) {
+                    if (typeUrlPrefix === undefined) {
+                        typeUrlPrefix = "type.googleapis.com";
+                    }
+                    return typeUrlPrefix + "/sqlanvil.MysqlOptions.Partition.Bound";
+                };
+
+                return Bound;
+            })();
+
+            return Partition;
+        })();
+
         return MysqlOptions;
     })();
 
@@ -43245,7 +43870,7 @@ class MysqlExecutionSql {
             if (table.materialized) {
                 tasks.add(Task.statement(this.dropIfExists(table.target, sqlanvil.TableMetadata.Type.VIEW)));
                 tasks.add(Task.statement(this.dropIfExists(table.target, sqlanvil.TableMetadata.Type.TABLE)));
-                tasks.add(Task.statement(`create table ${target}${this.tableOptions(table)} as ${table.query}`));
+                tasks.add(Task.statement(`create table ${target}${this.tableOptions(table)}${this.partitionClause(table)} as ${table.query}`));
                 this.createIndexes(table).forEach(stmt => tasks.add(Task.statement(stmt)));
             }
             else {
@@ -43256,7 +43881,7 @@ class MysqlExecutionSql {
             const fresh = !this.shouldWriteIncrementally(table, runConfig, tableMetadata);
             if (fresh) {
                 tasks.add(Task.statement(this.dropIfExists(table.target, sqlanvil.TableMetadata.Type.TABLE)));
-                tasks.add(Task.statement(`create table ${target}${this.tableOptions(table)} as ${table.query}`));
+                tasks.add(Task.statement(`create table ${target}${this.tableOptions(table)}${this.partitionClause(table)} as ${table.query}`));
                 if (table.uniqueKey && table.uniqueKey.length > 0) {
                     const idx = `uq_${table.target.schema}_${table.target.name}`.slice(0, 63);
                     const cols = table.uniqueKey.map(k => `\`${k}\``).join(", ");
@@ -43270,7 +43895,7 @@ class MysqlExecutionSql {
         }
         else {
             tasks.add(Task.statement(this.dropIfExists(table.target, sqlanvil.TableMetadata.Type.TABLE)));
-            tasks.add(Task.statement(`create table ${target}${this.tableOptions(table)} as ${table.query}`));
+            tasks.add(Task.statement(`create table ${target}${this.tableOptions(table)}${this.partitionClause(table)} as ${table.query}`));
             this.createIndexes(table).forEach(stmt => tasks.add(Task.statement(stmt)));
         }
         this.postOps(table, runConfig, tableMetadata).forEach(task => tasks.add(task));
@@ -43328,6 +43953,34 @@ class MysqlExecutionSql {
         const tail = updates.length > 0 ? ` on duplicate key update ${updates}` : "";
         return `insert into ${target} (${backticked.join(", ")}) select ${backticked.join(", ")} from (${query}) as insertions${tail}`;
     }
+    partitionKindAsSql(kind) {
+        switch (kind) {
+            case sqlanvil.MysqlOptions.Partition.Kind.LIST:
+                return "list";
+            case sqlanvil.MysqlOptions.Partition.Kind.HASH:
+                return "hash";
+            case sqlanvil.MysqlOptions.Partition.Kind.KEY:
+                return "key";
+            case sqlanvil.MysqlOptions.Partition.Kind.RANGE:
+            default:
+                return "range";
+        }
+    }
+    partitionClause(table) {
+        const partition = table.mysql && table.mysql.partition;
+        if (!partition) {
+            return "";
+        }
+        const kind = this.partitionKindAsSql(partition.kind);
+        const head = ` partition by ${kind} (${partition.expression})`;
+        if (kind === "hash" || kind === "key") {
+            return partition.count ? `${head} partitions ${partition.count}` : head;
+        }
+        const defs = (partition.partitions || [])
+            .map(bound => `partition ${bound.name} ${bound.values}`)
+            .join(", ");
+        return `${head} (${defs})`;
+    }
     tableOptions(table) {
         const opts = table.mysql;
         if (!opts) {
@@ -43792,7 +44445,7 @@ function collectEvaluationQueries(queryOrAction, concatenate, queryModifier = (q
         .filter(validationQuery => !!validationQuery.query);
 }
 
-const version = "1.9.0";
+const version = "1.11.0";
 const dataformVersion = "3.0.60";
 
 async function build(compiledGraph, runConfig, dbadapter) {
@@ -44291,6 +44944,9 @@ function mapBigQueryType(bqType) {
 function mapPostgresType(pgType) {
     return pgType.trim().toLowerCase();
 }
+function mapMysqlType(mysqlType) {
+    return mysqlType.trim().toLowerCase();
+}
 function keyToken(name) {
     return /^[A-Za-z_][A-Za-z0-9_]*$/.test(name) ? name : `"${name}"`;
 }
@@ -44392,6 +45048,40 @@ const readBigQuerySchema = function (resolved, sourceSchema, table) {
         });
     });
 };
+const readMysqlSchema = function (resolved, sourceSchema, table) {
+    const c = resolved.credentials;
+    let conn;
+    return mysql__namespace
+        .createConnection({
+        host: c.host || resolved.definition.host,
+        port: Number(c.port || resolved.definition.port || 3306),
+        database: c.database || resolved.definition.database,
+        user: c.user,
+        password: c.password,
+        ssl: c.sslMode && c.sslMode !== "disable" ? { rejectUnauthorized: false } : undefined
+    })
+        .then(function (connection) {
+        conn = connection;
+        return conn.query(`select column_name, data_type, column_comment
+         from information_schema.columns
+         where table_schema = ? and table_name = ?
+         order by ordinal_position`, [sourceSchema, table]);
+    })
+        .then(function (result) {
+        const rows = result[0] || [];
+        return rows.map(function (r) {
+            const name = r.column_name !== undefined ? r.column_name : r.COLUMN_NAME;
+            const type = r.data_type !== undefined ? r.data_type : r.DATA_TYPE;
+            const comment = r.column_comment !== undefined ? r.column_comment : r.COLUMN_COMMENT;
+            return { name, type, description: comment || undefined };
+        });
+    })
+        .then(function (cols) {
+        return conn.end().then(function () { return cols; });
+    }, function (err) {
+        return (conn ? conn.end() : Promise.resolve()).then(function () { throw err; }, function () { throw err; });
+    });
+};
 function defaultReaderFor(platform) {
     if (platform === "bigquery") {
         return readBigQuerySchema;
@@ -44399,6 +45089,9 @@ function defaultReaderFor(platform) {
     if (platform === "postgres" || platform === "supabase") {
         return readPostgresSchema;
     }
+    if (platform === "mysql") {
+        return readMysqlSchema;
+    }
     throw new Error(`introspect does not support source platform "${platform}".`);
 }
 function splitTableRef(tableRef) {
@@ -44417,7 +45110,11 @@ function introspectToSqlx(projectDir, connectionName, tableRef, options) {
         return Promise.reject(new Error(`Could not determine the source schema for "${tableRef}" on connection "${connectionName}". ` +
             `Pass it as "schema.table", or set "dataset"/"defaultSchema" on the connection.`));
     }
-    const mapType = resolved.definition.platform === "bigquery" ? mapBigQueryType : mapPostgresType;
+    const mapType = resolved.definition.platform === "bigquery"
+        ? mapBigQueryType
+        : resolved.definition.platform === "mysql"
+            ? mapMysqlType
+            : mapPostgresType;
     return reader(resolved, sourceSchema, parts.table).then(function (rawColumns) {
         if (rawColumns.length === 0) {
             throw new Error(`Source table "${tableRef}" on connection "${connectionName}" has no columns (does it exist?).`);
@@ -44459,6 +45156,53 @@ function assertConnectionCredentialsAvailable(graph, connections) {
     }));
 }
 
+function loadDuckdb() {
+    try {
+        return nativeRequire("@duckdb/node-api");
+    }
+    catch (e) {
+        throw new Error(`This feature requires the optional "@duckdb/node-api" dependency, which failed to load: ` +
+            `${e.message}`);
+    }
+}
+async function runAsync(conn, sql) {
+    await conn.run(sql);
+}
+async function allAsync(conn, sql) {
+    const reader = await conn.runAndReadAll(sql);
+    return reader.getRowObjects();
+}
+async function withDuckdb(fn, dbPath = ":memory:") {
+    const { DuckDBInstance } = loadDuckdb();
+    const instance = await DuckDBInstance.create(dbPath);
+    const conn = await instance.connect();
+    const done = () => {
+        var _a, _b;
+        try {
+            (_a = conn.closeSync) === null || _a === void 0 ? void 0 : _a.call(conn);
+        }
+        catch (e) {
+        }
+        try {
+            (_b = instance.closeSync) === null || _b === void 0 ? void 0 : _b.call(instance);
+        }
+        catch (e) {
+        }
+    };
+    try {
+        if (!process.env.HOME) {
+            await runAsync(conn, `SET home_directory='${os__namespace.tmpdir()}'`);
+        }
+        const result = await fn(conn);
+        done();
+        return result;
+    }
+    catch (e) {
+        done();
+        throw e;
+    }
+}
+
 const PG_ATTACH_ALIAS = "pg";
 const SECRET_NAME = "sa_export";
 function buildAttachSql(pg) {
@@ -44522,48 +45266,6 @@ function buildCopySql(selectSql, uri, format, options = {}) {
     const optionList = [`FORMAT ${fmt}`, ...extraOptions].join(", ");
     return `COPY (SELECT * FROM postgres_query('${PG_ATTACH_ALIAS}', $sa$${selectSql}$sa$)) TO '${target}' (${optionList})`;
 }
-function loadDuckdb() {
-    try {
-        return nativeRequire("@duckdb/node-api");
-    }
-    catch (e) {
-        throw new Error(`Exporting on Postgres/Supabase requires the optional "@duckdb/node-api" dependency, which ` +
-            `failed to load: ${e.message}`);
-    }
-}
-async function runAsync(conn, sql) {
-    await conn.run(sql);
-}
-async function withConnection(fn) {
-    const { DuckDBInstance } = loadDuckdb();
-    const instance = await DuckDBInstance.create(":memory:");
-    const conn = await instance.connect();
-    const done = () => {
-        var _a, _b;
-        try {
-            (_a = conn.closeSync) === null || _a === void 0 ? void 0 : _a.call(conn);
-        }
-        catch (e) {
-        }
-        try {
-            (_b = instance.closeSync) === null || _b === void 0 ? void 0 : _b.call(instance);
-        }
-        catch (e) {
-        }
-    };
-    try {
-        if (!process.env.HOME) {
-            await runAsync(conn, `SET home_directory='${os__namespace.tmpdir()}'`);
-        }
-        const result = await fn(conn);
-        done();
-        return result;
-    }
-    catch (e) {
-        done();
-        throw e;
-    }
-}
 async function runDuckdbExport(args) {
     const { spec, selectSql, pg, storage, actionName } = args;
     const uri = resolveExportUri(spec, actionName, { wildcard: false });
@@ -44572,7 +45274,7 @@ async function runDuckdbExport(args) {
         throw new Error(`No "${scheme}" storage credentials found in .df-credentials.json (storage.${scheme}) for ` +
             `export to ${uri}.`);
     }
-    return withConnection(async (conn) => {
+    return withDuckdb(async (conn) => {
         await runAsync(conn, "INSTALL postgres; LOAD postgres; INSTALL httpfs; LOAD httpfs;");
         await runAsync(conn, buildAttachSql(pg));
         if (scheme !== "local") {
@@ -45204,6 +45906,343 @@ function resolveCredentials(envCredentials, cliCredentials, defaultFilename) {
     return envCredentials || defaultFilename;
 }
 
+function key(target) {
+    return targetStringifier.stringify(target);
+}
+function enumName(enumObject, value) {
+    if (value === undefined || value === null) {
+        return "UNKNOWN";
+    }
+    const match = Object.keys(enumObject).find(k => enumObject[k] === value);
+    return match || String(value);
+}
+function tableType$1(enumType) {
+    switch (enumType) {
+        case sqlanvil.TableType.VIEW:
+            return "view";
+        case sqlanvil.TableType.INCREMENTAL:
+            return "incremental";
+        default:
+            return "table";
+    }
+}
+function toMillis(value) {
+    if (value === undefined || value === null) {
+        return 0;
+    }
+    if (typeof value === "number") {
+        return value;
+    }
+    if (typeof value.toNumber === "function") {
+        return value.toNumber();
+    }
+    return Number(value) || 0;
+}
+function actionRow(action, type) {
+    const descriptor = action.actionDescriptor || {};
+    return {
+        target_key: key(action.target),
+        database: action.target.database || "",
+        schema: action.target.schema || "",
+        name: action.target.name || "",
+        readable_name: targetAsReadableString(action.target),
+        type,
+        tags: JSON.stringify(action.tags || []),
+        disabled: !!action.disabled,
+        file_name: action.fileName || "",
+        description: descriptor.description || ""
+    };
+}
+function pushDeps(action, out) {
+    for (const dep of action.dependencyTargets || []) {
+        out.push({
+            from_target_key: key(action.target),
+            to_target_key: key(dep),
+            from_readable: targetAsReadableString(action.target),
+            to_readable: targetAsReadableString(dep)
+        });
+    }
+}
+function pushColumns(action, out) {
+    const columns = (action.actionDescriptor && action.actionDescriptor.columns) || [];
+    for (const column of columns) {
+        out.push({
+            target_key: key(action.target),
+            readable_name: targetAsReadableString(action.target),
+            column_name: (column.path || []).join("."),
+            description: column.description || ""
+        });
+    }
+}
+function catalogRows(compiledGraph) {
+    const actions = [];
+    const dependencies = [];
+    const columns = [];
+    const add = (action, type) => {
+        actions.push(actionRow(action, type));
+        pushDeps(action, dependencies);
+        pushColumns(action, columns);
+    };
+    for (const table of compiledGraph.tables || []) {
+        add(table, tableType$1(table.enumType));
+    }
+    for (const operation of compiledGraph.operations || []) {
+        add(operation, "operation");
+    }
+    for (const assertion of compiledGraph.assertions || []) {
+        add(assertion, "assertion");
+    }
+    for (const exp of compiledGraph.exports || []) {
+        add(exp, "export");
+    }
+    for (const declaration of compiledGraph.declarations || []) {
+        add(declaration, "declaration");
+    }
+    return { actions, dependencies, columns };
+}
+function runRows(runResult, runId) {
+    const runStatus = enumName(sqlanvil.RunResult.ExecutionStatus, runResult.status);
+    return (runResult.actions || []).map(action => {
+        const start = toMillis(action.timing && action.timing.startTimeMillis);
+        const end = toMillis(action.timing && action.timing.endTimeMillis);
+        const failedTask = (action.tasks || []).find(t => !!t.errorMessage);
+        return {
+            run_id: runId,
+            run_status: runStatus,
+            target_key: key(action.target),
+            readable_name: targetAsReadableString(action.target),
+            status: enumName(sqlanvil.ActionResult.ExecutionStatus, action.status),
+            start_millis: start,
+            end_millis: end,
+            duration_millis: start && end ? end - start : 0,
+            error_message: (failedTask && failedTask.errorMessage) || ""
+        };
+    });
+}
+
+let tmpCounter = 0;
+async function writeParquet(rows, outPath, columns) {
+    await fs__namespace.ensureDir(path__namespace.dirname(outPath));
+    const tmp = path__namespace.join(os__namespace.tmpdir(), `sa_artifact_${process.pid}_${Date.now()}_${tmpCounter++}.json`);
+    const payload = rows.length > 0 ? rows : [columns.reduce((o, c) => ((o[c] = null), o), {})];
+    const whereFalse = rows.length > 0 ? "" : " WHERE false";
+    await fs__namespace.writeFile(tmp, JSON.stringify(payload));
+    try {
+        await withDuckdb(async (conn) => {
+            await runAsync(conn, `COPY (SELECT * FROM read_json_auto('${tmp}')${whereFalse}) TO '${outPath}' (FORMAT parquet)`);
+        });
+    }
+    finally {
+        await fs__namespace.remove(tmp).catch(() => undefined);
+    }
+}
+async function queryParquet(sql, views) {
+    return withDuckdb(async (conn) => {
+        for (const view of views) {
+            await runAsync(conn, `create view ${view.name} as select * from read_parquet('${view.glob}')`);
+        }
+        return allAsync(conn, sql);
+    });
+}
+
+const TARGET_DIR = "target";
+const ACTION_COLUMNS = [
+    "target_key",
+    "database",
+    "schema",
+    "name",
+    "readable_name",
+    "type",
+    "tags",
+    "disabled",
+    "file_name",
+    "description"
+];
+const DEPENDENCY_COLUMNS = ["from_target_key", "to_target_key", "from_readable", "to_readable"];
+const COLUMN_COLUMNS = ["target_key", "readable_name", "column_name", "description"];
+const RUN_COLUMNS = [
+    "run_id",
+    "run_status",
+    "target_key",
+    "readable_name",
+    "status",
+    "start_millis",
+    "end_millis",
+    "duration_millis",
+    "error_message"
+];
+async function writeArtifacts(compiledGraph, projectDir, options = {}) {
+    const targetDir = path__namespace.join(projectDir, TARGET_DIR);
+    const catalogDir = path__namespace.join(targetDir, "catalog");
+    const { actions, dependencies, columns } = catalogRows(compiledGraph);
+    await writeParquet(actions, path__namespace.join(catalogDir, "actions.parquet"), ACTION_COLUMNS);
+    await writeParquet(dependencies, path__namespace.join(catalogDir, "dependencies.parquet"), DEPENDENCY_COLUMNS);
+    await writeParquet(columns, path__namespace.join(catalogDir, "columns.parquet"), COLUMN_COLUMNS);
+    if (options.runResult) {
+        const runId = options.runId !== undefined ? options.runId : Date.now();
+        await writeParquet(runRows(options.runResult, runId), path__namespace.join(targetDir, "runs", `run_${runId}.parquet`), RUN_COLUMNS);
+    }
+    return { targetDir };
+}
+async function safeWriteArtifacts(compiledGraph, projectDir, options = {}) {
+    try {
+        await writeArtifacts(compiledGraph, projectDir, options);
+    }
+    catch (e) {
+        if (options.warn) {
+            options.warn(`Artifacts skipped: ${e.message}`);
+        }
+    }
+}
+
+function escapeHtml(value) {
+    return String(value === null || value === undefined ? "" : value)
+        .replace(/&/g, "&amp;")
+        .replace(/</g, "&lt;")
+        .replace(/>/g, "&gt;")
+        .replace(/"/g, "&quot;");
+}
+async function buildDocsModel(views, generatedAt) {
+    const hasRuns = views.some(v => v.name === "runs");
+    const actions = await queryParquet("select readable_name, type, tags, description from actions order by type, readable_name", views);
+    const dependencies = await queryParquet("select from_readable, to_readable from dependencies", views);
+    const columns = await queryParquet("select readable_name, column_name, description from columns order by readable_name, column_name", views);
+    let latestRun;
+    const statusByModel = new Map();
+    if (hasRuns) {
+        const head = await queryParquet("select max(run_id) as run_id from runs", views);
+        const runId = head[0] && head[0].run_id !== null ? Number(head[0].run_id) : undefined;
+        if (runId !== undefined) {
+            const overall = await queryParquet(`select run_status from runs where run_id = ${runId} limit 1`, views);
+            latestRun = { runId, status: overall[0] ? overall[0].run_status : "UNKNOWN" };
+            const statuses = await queryParquet(`select readable_name, status from runs where run_id = ${runId}`, views);
+            for (const row of statuses) {
+                statusByModel.set(row.readable_name, row.status);
+            }
+        }
+    }
+    const dependsOn = new Map();
+    for (const dep of dependencies) {
+        dependsOn.set(dep.from_readable, (dependsOn.get(dep.from_readable) || []).concat(dep.to_readable));
+    }
+    const byTypeMap = new Map();
+    const models = actions.map(a => {
+        byTypeMap.set(a.type, (byTypeMap.get(a.type) || 0) + 1);
+        let tags = [];
+        try {
+            tags = JSON.parse(a.tags || "[]");
+        }
+        catch (e) {
+            tags = [];
+        }
+        return {
+            readable: a.readable_name,
+            type: a.type,
+            tags,
+            description: a.description || "",
+            status: statusByModel.get(a.readable_name),
+            dependsOn: dependsOn.get(a.readable_name) || []
+        };
+    });
+    return {
+        generatedAt,
+        summary: {
+            total: models.length,
+            byType: Array.from(byTypeMap.entries())
+                .map(([type, n]) => ({ type, n }))
+                .sort((x, y) => x.type.localeCompare(y.type))
+        },
+        latestRun,
+        models,
+        columns: columns.map(c => ({
+            readable: c.readable_name,
+            column: c.column_name,
+            description: c.description || ""
+        }))
+    };
+}
+function renderDocsHtml(model) {
+    const summaryLine = `${model.summary.total} models — ` +
+        model.summary.byType.map(t => `${t.n} ${t.type}`).join(", ");
+    const runLine = model.latestRun
+        ? `Last run: <strong>${escapeHtml(model.latestRun.status)}</strong> (run ${model.latestRun.runId})`
+        : "No runs recorded yet.";
+    const statusBadge = (status) => {
+        if (!status) {
+            return "";
+        }
+        const cls = status === "SUCCESSFUL" ? "ok" : status === "FAILED" ? "fail" : "muted";
+        return `<span class="badge ${cls}">${escapeHtml(status)}</span>`;
+    };
+    const modelRows = model.models
+        .map(m => `<tr data-search="${escapeHtml((m.readable + " " + m.type + " " + m.tags.join(" ")).toLowerCase())}">
+      <td><code>${escapeHtml(m.readable)}</code></td>
+      <td>${escapeHtml(m.type)}</td>
+      <td>${m.tags.map(t => `<span class="tag">${escapeHtml(t)}</span>`).join(" ")}</td>
+      <td>${statusBadge(m.status)}</td>
+      <td>${m.dependsOn.map(d => `<code>${escapeHtml(d)}</code>`).join("<br>")}</td>
+      <td>${escapeHtml(m.description)}</td>
+    </tr>`)
+        .join("\n");
+    const columnRows = model.columns
+        .map(c => `<tr><td><code>${escapeHtml(c.readable)}</code></td><td><code>${escapeHtml(c.column)}</code></td><td>${escapeHtml(c.description)}</td></tr>`)
+        .join("\n");
+    return `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>SQLAnvil catalog</title>
+<style>
+  :root { color-scheme: light dark; }
+  body { font: 14px/1.5 -apple-system, system-ui, sans-serif; margin: 2rem; max-width: 1100px; }
+  h1 { margin: 0 0 .25rem; }
+  .meta { color: #888; margin-bottom: 1.5rem; }
+  table { border-collapse: collapse; width: 100%; margin: 1rem 0 2rem; }
+  th, td { text-align: left; padding: .4rem .6rem; border-bottom: 1px solid #8884; vertical-align: top; }
+  th { font-weight: 600; }
+  code { font-size: 12px; }
+  .tag { background: #8883; border-radius: 4px; padding: 0 .35rem; font-size: 12px; }
+  .badge { border-radius: 4px; padding: 0 .4rem; font-size: 12px; font-weight: 600; }
+  .badge.ok { background: #1a7f37; color: #fff; }
+  .badge.fail { background: #b62324; color: #fff; }
+  .badge.muted { background: #8884; }
+  #q { padding: .4rem .6rem; width: 320px; max-width: 100%; margin-bottom: .5rem; }
+</style>
+</head>
+<body>
+  <h1>SQLAnvil catalog</h1>
+  <div class="meta">${escapeHtml(summaryLine)} &middot; ${runLine} &middot; generated ${escapeHtml(model.generatedAt)}</div>
+
+  <input id="q" type="search" placeholder="Filter models…" oninput="filterModels(this.value)">
+  <table id="models">
+    <thead><tr><th>Model</th><th>Type</th><th>Tags</th><th>Last run</th><th>Depends on</th><th>Description</th></tr></thead>
+    <tbody>
+${modelRows}
+    </tbody>
+  </table>
+
+  <h2>Columns</h2>
+  <table>
+    <thead><tr><th>Model</th><th>Column</th><th>Description</th></tr></thead>
+    <tbody>
+${columnRows || '<tr><td colspan="3" class="meta">No documented columns.</td></tr>'}
+    </tbody>
+  </table>
+
+<script>
+  function filterModels(q) {
+    q = q.toLowerCase();
+    for (const tr of document.querySelectorAll('#models tbody tr')) {
+      tr.style.display = tr.getAttribute('data-search').includes(q) ? '' : 'none';
+    }
+  }
+</script>
+</body>
+</html>
+`;
+}
+
 function targetKey(target) {
     return [target.database, target.schema, target.name].filter(Boolean).join(".");
 }
@@ -47964,6 +49003,11 @@ const timeoutOption = option("timeout", {
     default: null,
     coerce: (rawTimeoutString) => rawTimeoutString ? parseDuration__default["default"](rawTimeoutString) : null
 });
+const noArtifactsOption = option("no-artifacts", {
+    describe: "Skip writing the queryable Parquet artifacts under target/ (catalog on compile; run history " +
+        "on run).",
+    type: "boolean"
+});
 const keepShadowOption = option("keep-shadow", {
     describe: "If set, `validate` leaves its temporary shadow schema(s) in place instead of dropping them " +
         "(debugging aid).",
@@ -48132,6 +49176,106 @@ async function runValidate(argv) {
     const results = await validate(prunedGraph, deps, { keepShadow: argv[keepShadowOption.name] });
     return printValidationResults(results, argv[jsonOutputOption.name]);
 }
+function resolveArtifactViews(projectDir) {
+    const catalogDir = path__namespace.join(projectDir, TARGET_DIR, "catalog");
+    const runsDir = path__namespace.join(projectDir, TARGET_DIR, "runs");
+    const views = [];
+    for (const name of ["actions", "dependencies", "columns"]) {
+        const file = path__namespace.join(catalogDir, `${name}.parquet`);
+        if (fs__namespace$1.existsSync(file)) {
+            views.push({ name, glob: file });
+        }
+    }
+    const hasRuns = fs__namespace$1.existsSync(runsDir) && fs__namespace$1.readdirSync(runsDir).some(f => f.endsWith(".parquet"));
+    if (hasRuns) {
+        views.push({ name: "runs", glob: path__namespace.join(runsDir, "*.parquet") });
+    }
+    return { views, hasCatalog: views.some(v => v.name === "actions"), hasRuns };
+}
+function printArtifactRows(rows) {
+    if (!rows || rows.length === 0) {
+        print("(0 rows)");
+        return;
+    }
+    const cols = Object.keys(rows[0]);
+    const widths = cols.map(c => Math.max(c.length, ...rows.map(r => String(r[c] === null || r[c] === undefined ? "" : r[c]).length)));
+    const fmtRow = (vals) => vals.map((v, i) => v.padEnd(widths[i])).join("  ");
+    print(fmtRow(cols));
+    print(fmtRow(widths.map(w => "-".repeat(w))));
+    for (const row of rows) {
+        print(fmtRow(cols.map(c => String(row[c] === null || row[c] === undefined ? "" : row[c]))));
+    }
+    print(`\n(${rows.length} row${rows.length === 1 ? "" : "s"})`);
+}
+const NO_ARTIFACTS = "No artifacts found under target/. Run `sqlanvil compile` (or `run`) first.";
+async function runQuery(projectDir, sql, json) {
+    const { views, hasCatalog } = resolveArtifactViews(projectDir);
+    if (!hasCatalog) {
+        printError(NO_ARTIFACTS);
+        return 1;
+    }
+    const rows = await queryParquet(sql, views);
+    if (json) {
+        print(prettyJsonStringify(rows));
+    }
+    else {
+        printArtifactRows(rows);
+    }
+    return 0;
+}
+async function runInspect(projectDir, json) {
+    const { views, hasCatalog, hasRuns } = resolveArtifactViews(projectDir);
+    if (!hasCatalog) {
+        printError(NO_ARTIFACTS);
+        return 1;
+    }
+    const actionsByType = await queryParquet("select type, count(*) as n from actions group by type order by type", views);
+    let latestRun = null;
+    let failures = [];
+    if (hasRuns) {
+        const latest = await queryParquet("select run_id, run_status, " +
+            "count(*) filter (where status = 'SUCCESSFUL') as succeeded, " +
+            "count(*) filter (where status = 'FAILED') as failed, " +
+            "max(end_millis) - min(start_millis) as wall_ms " +
+            "from runs where run_id = (select max(run_id) from runs) group by run_id, run_status", views);
+        latestRun = latest[0] || null;
+        failures = await queryParquet("select readable_name, error_message from runs " +
+            "where run_id = (select max(run_id) from runs) and status = 'FAILED' limit 20", views);
+    }
+    if (json) {
+        print(prettyJsonStringify({ actionsByType, latestRun, failures }));
+        return 0;
+    }
+    print("Actions by type:");
+    printArtifactRows(actionsByType);
+    if (!hasRuns || !latestRun) {
+        print("\nNo runs recorded yet.");
+    }
+    else {
+        print(`\nLatest run (${latestRun.run_status}): ${latestRun.succeeded} succeeded, ` +
+            `${latestRun.failed} failed, ${latestRun.wall_ms}ms`);
+        if (failures.length > 0) {
+            print("\nFailures:");
+            printArtifactRows(failures);
+        }
+    }
+    return 0;
+}
+async function runDocs(projectDir) {
+    const { views, hasCatalog } = resolveArtifactViews(projectDir);
+    if (!hasCatalog) {
+        printError(NO_ARTIFACTS);
+        return 1;
+    }
+    const model = await buildDocsModel(views, new Date().toISOString());
+    const html = renderDocsHtml(model);
+    const outDir = path__namespace.join(projectDir, TARGET_DIR, "docs");
+    fs__namespace$1.mkdirSync(outDir, { recursive: true });
+    const outFile = path__namespace.join(outDir, "index.html");
+    fs__namespace$1.writeFileSync(outFile, html);
+    printSuccess(`Wrote catalog to ${outFile}`);
+    return 0;
+}
 function runCli() {
     const builtYargs = createYargsCli({
         commands: [
@@ -48262,6 +49406,7 @@ function runCli() {
                     compileTagsOption,
                     compileIncludeDepsOption,
                     compileIncludeDependentsOption,
+                    noArtifactsOption,
                     option(verboseOptionName, {
                         describe: "Enable verbose compilation output. Example usage: 'sqlanvil compile --verbose'",
                         type: "boolean",
@@ -48308,6 +49453,9 @@ function runCli() {
                             printCompiledGraphErrors(compiledGraph.graphErrors, argv[quietCompileOption.name]);
                             return true;
                         }
+                        if (!argv[noArtifactsOption.name]) {
+                            await safeWriteArtifacts(compiledGraph, projectDir, { warn: print });
+                        }
                         return false;
                     }
                     const graphHasErrors = await compileAndPrint();
@@ -48458,6 +49606,7 @@ function runCli() {
                     timeoutOption,
                     tagsOption,
                     bigqueryJobLabelsOption,
+                    noArtifactsOption,
                     ...ProjectConfigOptions.allYargsOptions
                 ],
                 processFn: async (argv) => {
@@ -48572,9 +49721,47 @@ function runCli() {
                     runner.onChange(printExecutedGraph);
                     const runResult = await runner.result();
                     printExecutedGraph(runResult);
+                    if (!argv[noArtifactsOption.name]) {
+                        await safeWriteArtifacts(compiledGraph, argv[projectDirOption.name], {
+                            runResult,
+                            runId: Date.now(),
+                            warn: print
+                        });
+                    }
                     return runResult.status === sqlanvil.RunResult.ExecutionStatus.SUCCESSFUL ? 0 : 1;
                 }
             },
+            {
+                format: `query [sql] [${projectDirOption.name}]`,
+                description: "Run SQL over the project's queryable artifacts in target/ (views: actions, " +
+                    "dependencies, columns, runs), via the bundled DuckDB.",
+                positionalOptions: [
+                    positionalOption("sql", { describe: 'SQL to run, e.g. "select type, count(*) from actions group by 1".' }, (argv) => {
+                        if (!argv.sql) {
+                            throw new Error('Provide a SQL query, e.g. sqlanvil query "select * from actions".');
+                        }
+                    }),
+                    projectDirOption
+                ],
+                options: [jsonOutputOption],
+                processFn: async (argv) => runQuery(argv[projectDirOption.name], argv.sql, argv[jsonOutputOption.name])
+            },
+            {
+                format: `inspect [${projectDirOption.name}]`,
+                description: "Summarize the project's artifacts: action counts by type, the latest run's status/" +
+                    "timing, and recent failures.",
+                positionalOptions: [projectDirOption],
+                options: [jsonOutputOption],
+                processFn: async (argv) => runInspect(argv[projectDirOption.name], argv[jsonOutputOption.name])
+            },
+            {
+                format: `docs [${projectDirOption.name}]`,
+                description: "Generate a self-contained HTML catalog of the project (models, columns, dependencies, " +
+                    "last-run status) at target/docs/index.html, from the artifacts.",
+                positionalOptions: [projectDirOption],
+                options: [],
+                processFn: async (argv) => runDocs(argv[projectDirOption.name])
+            },
             {
                 format: `format [${projectDirMustExistOption.name}]`,
                 description: "Format the sqlanvil project's files.",